delayed_job_unique_key 0.0.4 → 0.1.0

data/lib/delayed/serialization/active_record.rb

@@ -1,19 +0,0 @@
-if defined?(ActiveRecord)
-  class ActiveRecord::Base
-    yaml_as "tag:ruby.yaml.org,2002:ActiveRecord"
-
-    def self.yaml_new(klass, tag, val)
-      if ActiveRecord::VERSION::MAJOR == 3
-        klass.unscoped.find(val['attributes'][klass.primary_key])
-      else # Rails 2
-        klass.with_exclusive_scope { klass.find(val['attributes'][klass.primary_key]) }
-      end
-    rescue ActiveRecord::RecordNotFound
-      raise Delayed::DeserializationError
-    end
-
-    def to_yaml_properties
-      ['@attributes']
-    end
-  end
-end

data/lib/delayed/syck_ext.rb

@@ -1,34 +0,0 @@
-class Module
-  yaml_as "tag:ruby.yaml.org,2002:module"
-
-  def self.yaml_new(klass, tag, val)
-    klass
-  end
-
-  def to_yaml(options = {})
-    YAML.quick_emit(nil, options) do |out|
-      out.scalar(taguri, name, :plain)
-    end
-  end
-
-  def yaml_tag_read_class(name)
-    # Constantize the object so that ActiveSupport can attempt
-    # its auto loading magic. Will raise LoadError if not successful.
-    name.constantize
-    name
-  end
-end
-
-class Class
-  yaml_as "tag:ruby.yaml.org,2002:class"
-  remove_method :to_yaml if respond_to?(:to_yaml) && method(:to_yaml).owner == Class # use Module's to_yaml
-end
-
-class Struct
-  def self.yaml_tag_read_class(name)
-    # Constantize the object so that ActiveSupport can attempt
-    # its auto loading magic. Will raise LoadError if not successful.
-    name.constantize
-    "Struct::#{ name }"
-  end
-end

data/lib/delayed/tasks.rb

@@ -1,11 +0,0 @@
-namespace :jobs do
-  desc "Clear the delayed_job queue."
-  task :clear => :environment do
-    Delayed::Job.delete_all
-  end
-
-  desc "Start a delayed_job worker."
-  task :work => :environment do
-    Delayed::Worker.new(:min_priority => ENV['MIN_PRIORITY'], :max_priority => ENV['MAX_PRIORITY'], :queues => (ENV['QUEUES'] || ENV['QUEUE'] || '').split(','), :quiet => false).start
-  end
-end

data/lib/delayed/worker.rb

@@ -1,222 +0,0 @@
-require 'timeout'
-require 'active_support/core_ext/numeric/time'
-require 'active_support/core_ext/class/attribute_accessors'
-require 'active_support/core_ext/kernel'
-require 'active_support/core_ext/enumerable'
-require 'logger'
-
-module Delayed
-  class Worker
-    cattr_accessor :min_priority, :max_priority, :max_attempts, :max_run_time, :default_priority, :sleep_delay, :logger, :delay_jobs, :queues
-    self.sleep_delay = 5
-    self.max_attempts = 25
-    self.max_run_time = 4.hours
-    self.default_priority = 0
-    self.delay_jobs = true
-    self.queues = []
-
-    # Add or remove plugins in this list before the worker is instantiated
-    cattr_accessor :plugins
-    self.plugins = [Delayed::Plugins::ClearLocks]
-
-    # By default failed jobs are destroyed after too many attempts. If you want to keep them around
-    # (perhaps to inspect the reason for the failure), set this to false.
-    cattr_accessor :destroy_failed_jobs
-    self.destroy_failed_jobs = true
-
-    self.logger = if defined?(Rails)
-      Rails.logger
-    elsif defined?(RAILS_DEFAULT_LOGGER)
-      RAILS_DEFAULT_LOGGER
-    end
-
-    # name_prefix is ignored if name is set directly
-    attr_accessor :name_prefix
-
-    cattr_reader :backend
-
-    def self.backend=(backend)
-      if backend.is_a? Symbol
-        require "delayed/serialization/#{backend}" if YAML.parser.class.name =~ /syck/i
-        require "delayed/backend/#{backend}"
-        backend = "Delayed::Backend::#{backend.to_s.classify}::Job".constantize
-      end
-      @@backend = backend
-      silence_warnings { ::Delayed.const_set(:Job, backend) }
-    end
-
-    def self.guess_backend
-      warn "[DEPRECATION] guess_backend is deprecated. Please remove it from your code."
-    end
-
-    def self.before_fork
-      unless @files_to_reopen
-        @files_to_reopen = []
-        ObjectSpace.each_object(File) do |file|
-          @files_to_reopen << file unless file.closed?
-        end
-      end
-
-      backend.before_fork
-    end
-
-    def self.after_fork
-      # Re-open file handles
-      @files_to_reopen.each do |file|
-        begin
-          file.reopen file.path, "a+"
-          file.sync = true
-        rescue ::Exception
-        end
-      end
-
-      backend.after_fork
-    end
-
-    def self.lifecycle
-      @lifecycle ||= Delayed::Lifecycle.new
-    end
-
-    def initialize(options={})
-      @quiet = options.has_key?(:quiet) ? options[:quiet] : true
-      self.class.min_priority = options[:min_priority] if options.has_key?(:min_priority)
-      self.class.max_priority = options[:max_priority] if options.has_key?(:max_priority)
-      self.class.sleep_delay = options[:sleep_delay] if options.has_key?(:sleep_delay)
-      self.class.queues = options[:queues] if options.has_key?(:queues)
-
-      self.plugins.each { |klass| klass.new }
-    end
-
-    # Every worker has a unique name which by default is the pid of the process. There are some
-    # advantages to overriding this with something which survives worker retarts:  Workers can#
-    # safely resume working on tasks which are locked by themselves. The worker will assume that
-    # it crashed before.
-    def name
-      return @name unless @name.nil?
-      "#{@name_prefix}host:#{Socket.gethostname} pid:#{Process.pid}" rescue "#{@name_prefix}pid:#{Process.pid}"
-    end
-
-    # Sets the name of the worker.
-    # Setting the name to nil will reset the default worker name
-    def name=(val)
-      @name = val
-    end
-
-    def start
-      trap('TERM') { say 'Exiting...'; stop }
-      trap('INT')  { say 'Exiting...'; stop }
-
-      say "Starting job worker"
-
-      self.class.lifecycle.run_callbacks(:execute, self) do
-        loop do
-          self.class.lifecycle.run_callbacks(:loop, self) do
-            result = nil
-
-            realtime = Benchmark.realtime do
-              result = work_off
-            end
-
-            count = result.sum
-
-            break if @exit
-
-            if count.zero?
-              sleep(self.class.sleep_delay)
-            else
-              say "#{count} jobs processed at %.4f j/s, %d failed ..." % [count / realtime, result.last]
-            end
-          end
-
-          break if @exit
-        end
-      end
-    end
-
-    def stop
-      @exit = true
-    end
-
-    # Do num jobs and return stats on success/failure.
-    # Exit early if interrupted.
-    def work_off(num = 100)
-      success, failure = 0, 0
-
-      num.times do
-        case reserve_and_run_one_job
-        when true
-            success += 1
-        when false
-            failure += 1
-        else
-          break  # leave if no work could be done
-        end
-        break if $exit # leave if we're exiting
-      end
-
-      return [success, failure]
-    end
-
-    def run(job)
-      runtime =  Benchmark.realtime do
-        Timeout.timeout(self.class.max_run_time.to_i) { job.invoke_job }
-        job.destroy
-      end
-      say "#{job.name} completed after %.4f" % runtime
-      return true  # did work
-    rescue DeserializationError => error
-      job.last_error = "{#{error.message}\n#{error.backtrace.join("\n")}"
-      failed(job)
-    rescue Exception => error
-      self.class.lifecycle.run_callbacks(:error, self, job){ handle_failed_job(job, error) }
-      return false  # work failed
-    end
-
-    # Reschedule the job in the future (when a job fails).
-    # Uses an exponential scale depending on the number of failed attempts.
-    def reschedule(job, time = nil)
-      if (job.attempts += 1) < max_attempts(job)
-        time ||= job.reschedule_at
-        job.run_at = time
-        job.unlock
-        job.save!
-      else
-        say "PERMANENTLY removing #{job.name} because of #{job.attempts} consecutive failures.", Logger::INFO
-        failed(job)
-      end
-    end
-
-    def failed(job)
-      self.class.lifecycle.run_callbacks(:failure, self, job) do
-        job.hook(:failure)
-        self.class.destroy_failed_jobs ? job.destroy : job.fail!
-      end
-    end
-
-    def say(text, level = Logger::INFO)
-      text = "[Worker(#{name})] #{text}"
-      puts text unless @quiet
-      logger.add level, "#{Time.now.strftime('%FT%T%z')}: #{text}" if logger
-    end
-
-    def max_attempts(job)
-      job.max_attempts || self.class.max_attempts
-    end
-
-  protected
-
-    def handle_failed_job(job, error)
-      job.last_error = "{#{error.message}\n#{error.backtrace.join("\n")}"
-      say "#{job.name} failed with #{error.class.name}: #{error.message} - #{job.attempts} failed attempts", Logger::ERROR
-      reschedule(job)
-    end
-
-    # Run the next job we can get an exclusive lock on.
-    # If no jobs are left we return nil
-    def reserve_and_run_one_job
-      job = Delayed::Job.reserve(self)
-      self.class.lifecycle.run_callbacks(:perform, self, job){ result = run(job) } if job
-    end
-  end
-
-end

data/lib/delayed/yaml_ext.rb

@@ -1,10 +0,0 @@
-# These extensions allow properly serializing and autoloading of
-# Classes, Modules and Structs
-
-require 'yaml'
-if YAML.parser.class.name =~ /syck/i
-  require File.expand_path('../syck_ext', __FILE__)
-  require File.expand_path('../serialization/active_record', __FILE__)
-else
-  require File.expand_path('../psych_ext', __FILE__)
-end

data/lib/delayed_job.rb

@@ -1,22 +0,0 @@
-require 'active_support'
-
-require File.dirname(__FILE__) + '/delayed/message_sending'
-require File.dirname(__FILE__) + '/delayed/performable_method'
-
-# PerformableMailer is compatible with ActionMailer 3 (and possibly 3.1)
-if defined?(ActionMailer)
-  require 'action_mailer/version'
-  require File.dirname(__FILE__) + '/delayed/performable_mailer' if 3 == ActionMailer::VERSION::MAJOR
-end
-
-require File.dirname(__FILE__) + '/delayed/yaml_ext'
-require File.dirname(__FILE__) + '/delayed/lifecycle'
-require File.dirname(__FILE__) + '/delayed/plugin'
-require File.dirname(__FILE__) + '/delayed/plugins/clear_locks'
-require File.dirname(__FILE__) + '/delayed/backend/base'
-require File.dirname(__FILE__) + '/delayed/worker'
-require File.dirname(__FILE__) + '/delayed/deserialization_error'
-require File.dirname(__FILE__) + '/delayed/railtie' if defined?(Rails::Railtie)
-
-Object.send(:include, Delayed::MessageSending)
-Module.send(:include, Delayed::MessageSending::ClassMethods)

data/lib/generators/delayed_job/delayed_job_generator.rb

@@ -1,11 +0,0 @@
-require 'rails/generators'
-
-class DelayedJobGenerator < Rails::Generators::Base
-  
-  self.source_paths << File.join(File.dirname(__FILE__), 'templates')
-  
-  def create_script_file
-    template 'script', 'script/delayed_job'
-    chmod 'script/delayed_job', 0755
-  end
-end

data/lib/generators/delayed_job/templates/script

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'config', 'environment'))
-require 'delayed/command'
-Delayed::Command.new(ARGV).daemonize

data/recipes/delayed_job.rb

@@ -1 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'delayed', 'recipes'))

data/spec/autoloaded/clazz.rb

@@ -1,7 +0,0 @@
-# Make sure this file does not get required manually
-module Autoloaded
-  class Clazz
-    def perform
-    end
-  end
-end

data/spec/autoloaded/instance_clazz.rb

@@ -1,6 +0,0 @@
-module Autoloaded
-  class InstanceClazz
-    def perform
-    end
-  end
-end

data/spec/autoloaded/instance_struct.rb

@@ -1,6 +0,0 @@
-module Autoloaded
-  class InstanceStruct < ::Struct.new(nil)
-    def perform
-    end
-  end
-end

data/spec/autoloaded/struct.rb

@@ -1,7 +0,0 @@
-# Make sure this file does not get required manually
-module Autoloaded
-  class Struct < ::Struct.new(nil)
-    def perform
-    end
-  end
-end

data/spec/delayed/backend/test.rb

@@ -1,113 +0,0 @@
-require 'ostruct'
-
-# An in-memory backend suitable only for testing. Tries to behave as if it were an ORM.
-module Delayed
-  module Backend
-    module Test
-      class Job
-        attr_accessor :id
-        attr_accessor :priority
-        attr_accessor :attempts
-        attr_accessor :handler
-        attr_accessor :last_error
-        attr_accessor :run_at
-        attr_accessor :locked_at
-        attr_accessor :locked_by
-        attr_accessor :failed_at
-        attr_accessor :queue
-        attr_accessor :unique_key
-        
-        include Delayed::Backend::Base
-
-        cattr_accessor :id
-        self.id = 0
-        
-        def initialize(hash = {})
-          self.attempts = 0
-          self.priority = 0
-          self.id = (self.class.id += 1)
-          hash.each{|k,v| send(:"#{k}=", v)}
-        end
-        
-        @jobs = []
-        def self.all
-          @jobs
-        end
-        
-        def self.count 
-          all.size
-        end
-        
-        def self.delete_all
-          all.clear
-        end
-        
-        def self.create(attrs = {})
-          new(attrs).tap do |o|
-            o.save
-          end
-        end
-        
-        def self.create!(*args); create(*args); end
-        
-        def self.clear_locks!(worker_name)
-          all.select{|j| j.locked_by == worker_name}.each {|j| j.locked_by = nil; j.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)
-          jobs = all.select do |j| 
-            j.run_at <= db_time_now && 
-            (j.locked_at.nil? || j.locked_at < db_time_now - max_run_time || j.locked_by == worker_name) &&
-            j.failed_at.nil?
-          end
-                    
-          jobs = jobs.select{|j| Worker.queues.include?(j.queue)}   if Worker.queues.any?
-          jobs = jobs.select{|j| j.priority >= Worker.min_priority} if Worker.min_priority
-          jobs = jobs.select{|j| j.priority <= Worker.max_priority} if Worker.max_priority          
-          jobs.sort_by{|j| [j.priority, j.run_at]}[0..limit-1]
-        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
-          if locked_by != worker
-            # We don't own this job so we will update the locked_by name and the locked_at
-            self.locked_at = now
-            self.locked_by = worker
-          end
-
-          return true
-        end
-
-        def self.db_time_now
-          Time.current
-        end
-        
-        def update_attributes(attrs = {})
-          attrs.each{|k,v| send(:"#{k}=", v)}
-          save
-        end
-        
-        def destroy
-          self.class.all.delete(self)
-        end
-        
-        def save
-          self.run_at ||= Time.current
-          
-          self.class.all << self unless self.class.all.include?(self)
-          true
-        end
-        
-        def save!; save; end
-               
-        def reload
-          reset
-          self
-        end
-      end
-    end
-  end
-end