delayed_job_unique_key 0.0.4 → 0.1.0

data/lib/delayed/command.rb

@@ -1,101 +0,0 @@
-require 'daemons'
-require 'optparse'
-
-module Delayed
-  class Command
-    attr_accessor :worker_count
-
-    def initialize(args)
-      @options = {
-        :quiet => true,
-        :pid_dir => "#{Rails.root}/tmp/pids"
-      }
-
-      @worker_count = 1
-      @monitor = false
-
-      opts = OptionParser.new do |opts|
-        opts.banner = "Usage: #{File.basename($0)} [options] start|stop|restart|run"
-
-        opts.on('-h', '--help', 'Show this message') do
-          puts opts
-          exit 1
-        end
-        opts.on('-e', '--environment=NAME', 'Specifies the environment to run this delayed jobs under (test/development/production).') do |e|
-          STDERR.puts "The -e/--environment option has been deprecated and has no effect. Use RAILS_ENV and see http://github.com/collectiveidea/delayed_job/issues/#issue/7"
-        end
-        opts.on('--min-priority N', 'Minimum priority of jobs to run.') do |n|
-          @options[:min_priority] = n
-        end
-        opts.on('--max-priority N', 'Maximum priority of jobs to run.') do |n|
-          @options[:max_priority] = n
-        end
-        opts.on('-n', '--number_of_workers=workers', "Number of unique workers to spawn") do |worker_count|
-          @worker_count = worker_count.to_i rescue 1
-        end
-        opts.on('--pid-dir=DIR', 'Specifies an alternate directory in which to store the process ids.') do |dir|
-          @options[:pid_dir] = dir
-        end
-        opts.on('-i', '--identifier=n', 'A numeric identifier for the worker.') do |n|
-          @options[:identifier] = n
-        end
-        opts.on('-m', '--monitor', 'Start monitor process.') do
-          @monitor = true
-        end
-        opts.on('--sleep-delay N', "Amount of time to sleep when no jobs are found") do |n|
-          @options[:sleep_delay] = n
-        end
-        opts.on('-p', '--prefix NAME', "String to be prefixed to worker process names") do |prefix|
-          @options[:prefix] = prefix
-        end
-        opts.on('--queues=queues', "Specify which queue DJ must look up for jobs") do |queues|
-          @options[:queues] = queues.split(',')
-        end
-        opts.on('--queue=queue', "Specify which queue DJ must look up for jobs") do |queue|
-          @options[:queues] = queue.split(',')
-        end
-      end
-      @args = opts.parse!(args)
-    end
-
-    def daemonize
-      dir = @options[:pid_dir]
-      Dir.mkdir(dir) unless File.exists?(dir)
-
-      if @worker_count > 1 && @options[:identifier]
-        raise ArgumentError, 'Cannot specify both --number-of-workers and --identifier'
-      elsif @worker_count == 1 && @options[:identifier]
-        process_name = "delayed_job.#{@options[:identifier]}"
-        run_process(process_name, dir)
-      else
-        worker_count.times do |worker_index|
-          process_name = worker_count == 1 ? "delayed_job" : "delayed_job.#{worker_index}"
-          run_process(process_name, dir)
-        end
-      end
-    end
-
-    def run_process(process_name, dir)
-      Delayed::Worker.before_fork
-      Daemons.run_proc(process_name, :dir => dir, :dir_mode => :normal, :monitor => @monitor, :ARGV => @args) do |*args|
-        $0 = File.join(@options[:prefix], process_name) if @options[:prefix]
-        run process_name
-      end
-    end
-
-    def run(worker_name = nil)
-      Dir.chdir(Rails.root)
-
-      Delayed::Worker.after_fork
-      Delayed::Worker.logger = Logger.new(File.join(Rails.root, 'log', 'delayed_job.log'))
-
-      worker = Delayed::Worker.new(@options)
-      worker.name_prefix = "#{worker_name} "
-      worker.start
-    rescue => e
-      Rails.logger.fatal e
-      STDERR.puts e.message
-      exit 1
-    end
-  end
-end

data/lib/delayed/deserialization_error.rb

@@ -1,4 +0,0 @@
-module Delayed
-  class DeserializationError < StandardError
-  end
-end

data/lib/delayed/lifecycle.rb

@@ -1,84 +0,0 @@
-module Delayed
-  class InvalidCallback < Exception; end
-  
-  class Lifecycle
-    EVENTS = {
-      :enqueue => [:job], 
-      :execute => [:worker], 
-      :loop => [:worker], 
-      :perform => [:worker, :job], 
-      :error => [:worker, :job], 
-      :failure => [:worker, :job], 
-      :invoke_job => [:job]
-    }
-    
-    def initialize
-      @callbacks = EVENTS.keys.inject({}) { |hash, e| hash[e] = Callback.new; hash }
-    end
-    
-    def before(event, &block)
-      add(:before, event, &block)
-    end
-    
-    def after(event, &block)
-      add(:after, event, &block)
-    end
-    
-    def around(event, &block)
-      add(:around, event, &block)
-    end
-    
-    def run_callbacks(event, *args, &block)
-      missing_callback(event) unless @callbacks.has_key?(event)
-      
-      unless EVENTS[event].size == args.size
-        raise ArgumentError, "Callback #{event} expects #{EVENTS[event].size} parameter(s): #{EVENTS[event].join(', ')}"
-      end
-      
-      @callbacks[event].execute(*args, &block)
-    end
-    
-    private
-    
-      def add(type, event, &block)
-        missing_callback(event) unless @callbacks.has_key?(event)
-
-        @callbacks[event].add(type, &block)
-      end
-      
-      def missing_callback(event)
-        raise InvalidCallback, "Unknown callback event: #{event}"
-      end
-  end
-  
-  class Callback
-    def initialize
-      @before = []
-      @after = []
-      
-      # Identity proc. Avoids special cases when there is no existing around chain.
-      @around = lambda { |*args, &block| block.call(*args) }
-    end
-    
-    def execute(*args, &block)      
-      @before.each { |c| c.call(*args) }
-      result = @around.call(*args, &block)
-      @after.each { |c| c.call(*args) }
-      result
-    end
-    
-    def add(type, &callback)      
-      case type
-      when :before
-        @before << callback
-      when :after
-        @after << callback
-      when :around
-        chain = @around # use a local variable so that the current chain is closed over in the following lambda
-        @around = lambda { |*a, &block| chain.call(*a) { |*b| callback.call(*b, &block) } }
-      else
-        raise InvalidCallback, "Invalid callback type: #{type}"
-      end
-    end
-  end
-end

data/lib/delayed/message_sending.rb

@@ -1,54 +0,0 @@
-require 'active_support/basic_object'
-require 'active_support/core_ext/module/aliasing'
-
-module Delayed
-  class DelayProxy < ActiveSupport::BasicObject
-    def initialize(payload_class, target, options)
-      @payload_class = payload_class
-      @target = target
-      @options = options
-    end
-
-    def method_missing(method, *args)
-      Job.enqueue({:payload_object => @payload_class.new(@target, method.to_sym, args)}.merge(@options))
-    end
-  end
-
-  module MessageSending
-    def delay(options = {})
-      DelayProxy.new(PerformableMethod, self, options)
-    end
-    alias __delay__ delay
-
-    def send_later(method, *args)
-      warn "[DEPRECATION] `object.send_later(:method)` is deprecated. Use `object.delay.method"
-      __delay__.__send__(method, *args)
-    end
-
-    def send_at(time, method, *args)
-      warn "[DEPRECATION] `object.send_at(time, :method)` is deprecated. Use `object.delay(:run_at => time).method"
-      __delay__(:run_at => time).__send__(method, *args)
-    end
-
-    module ClassMethods
-      def handle_asynchronously(method, opts = {})
-        aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
-        with_method, without_method = "#{aliased_method}_with_delay#{punctuation}", "#{aliased_method}_without_delay#{punctuation}"
-        define_method(with_method) do |*args|
-          curr_opts = opts.clone
-          curr_opts.each_key do |key|
-            if (val = curr_opts[key]).is_a?(Proc)
-              curr_opts[key] = if val.arity == 1
-                val.call(self)
-              else
-                val.call
-              end
-            end
-          end
-          delay(curr_opts).__send__(without_method, *args)
-        end
-        alias_method_chain method, :delay
-      end
-    end
-  end
-end

data/lib/delayed/performable_mailer.rb

@@ -1,21 +0,0 @@
-require 'mail'
-
-module Delayed
-  class PerformableMailer < PerformableMethod
-    def perform
-      object.send(method_name, *args).deliver
-    end
-  end
-
-  module DelayMail
-    def delay(options = {})
-      DelayProxy.new(PerformableMailer, self, options)
-    end
-  end
-end
-
-Mail::Message.class_eval do
-  def delay(*args)
-    raise RuntimeError, "Use MyMailer.delay.mailer_action(args) to delay sending of emails."
-  end
-end

data/lib/delayed/performable_method.rb

@@ -1,33 +0,0 @@
-require 'active_support/core_ext/module/delegation'
-
-module Delayed
-  class PerformableMethod
-    attr_accessor :object, :method_name, :args
-
-    delegate :method, :to => :object
-
-    def initialize(object, method_name, args)
-      raise NoMethodError, "undefined method `#{method_name}' for #{object.inspect}" unless object.respond_to?(method_name, true)
-
-      self.object       = object
-      self.args         = args
-      self.method_name  = method_name.to_sym
-    end
-
-    def display_name
-      "#{object.class}##{method_name}"
-    end
-
-    def perform
-      object.send(method_name, *args) if object
-    end
-
-    def method_missing(symbol, *args)
-      object.send(symbol, *args)
-    end
-
-    def respond_to?(symbol, include_private=false)
-      super || object.respond_to?(symbol, include_private)
-    end
-  end
-end

data/lib/delayed/plugin.rb

@@ -1,15 +0,0 @@
-require 'active_support/core_ext/class/attribute'
-
-module Delayed
-  class Plugin
-    class_attribute :callback_block
-
-    def self.callbacks(&block)
-      self.callback_block = block
-    end
-
-    def initialize
-      self.class.callback_block.call(Delayed::Worker.lifecycle) if self.class.callback_block
-    end
-  end
-end

data/lib/delayed/plugins/clear_locks.rb

@@ -1,15 +0,0 @@
-module Delayed
-  module Plugins
-    class ClearLocks < Plugin
-      callbacks do |lifecycle|
-        lifecycle.around(:execute) do |worker, &block|
-          begin
-            block.call(worker)
-          ensure            
-            Delayed::Job.clear_locks!(worker.name)
-          end
-        end 
-      end
-    end
-  end
-end

data/lib/delayed/psych_ext.rb

@@ -1,75 +0,0 @@
-if defined?(ActiveRecord)
-  class ActiveRecord::Base
-    # serialize to YAML
-    def encode_with(coder)
-      coder["attributes"] = @attributes
-      coder.tag = ['!ruby/ActiveRecord', self.class.name].join(':')
-    end
-  end
-end
-
-class Delayed::PerformableMethod
-  # serialize to YAML
-  def encode_with(coder)
-    coder.map = {
-      "object" => object,
-      "method_name" => method_name,
-      "args" => args
-    }
-  end
-end
-
-module Psych
-  module Visitors
-    class YAMLTree
-      def visit_Class(klass)
-        tag = ['!ruby/class', klass.name].join(':')
-        register(klass, @emitter.start_mapping(nil, tag, false, Nodes::Mapping::BLOCK))
-        @emitter.end_mapping
-      end
-    end
-
-    class ToRuby
-      def visit_Psych_Nodes_Mapping_with_class(object)
-        return revive(Psych.load_tags[object.tag], object) if Psych.load_tags[object.tag]
-
-        case object.tag
-        when /^!ruby\/class:?(.*)?$/
-          resolve_class $1
-        when /^!ruby\/ActiveRecord:(.+)$/
-          klass = resolve_class($1)
-          payload = Hash[*object.children.map { |c| accept c }]
-          id = payload["attributes"][klass.primary_key]
-          begin
-            if ActiveRecord::VERSION::MAJOR == 3
-              klass.unscoped.find(id)
-            else # Rails 2
-              klass.with_exclusive_scope { klass.find(id) }
-            end
-          rescue ActiveRecord::RecordNotFound
-            raise Delayed::DeserializationError
-          end
-        when /^!ruby\/Mongoid:(.+)$/
-          klass = resolve_class($1)
-          payload = Hash[*object.children.map { |c| accept c }]
-          begin
-            klass.find(payload["attributes"]["_id"])
-          rescue Mongoid::Errors::DocumentNotFound
-            raise Delayed::DeserializationError
-          end
-        else
-          visit_Psych_Nodes_Mapping_without_class(object)
-        end
-      end
-      alias_method_chain :visit_Psych_Nodes_Mapping, :class
-
-      def resolve_class_with_constantize(klass_name)
-        klass_name.constantize
-      rescue
-        resolve_class_without_constantize(klass_name)
-      end
-      alias_method_chain :resolve_class, :constantize
-    end
-  end
-end
-

data/lib/delayed/railtie.rb

@@ -1,16 +0,0 @@
-require 'delayed_job'
-require 'rails'
-
-module Delayed
-  class Railtie < Rails::Railtie
-    initializer :after_initialize do
-      ActiveSupport.on_load(:action_mailer) do
-        ActionMailer::Base.send(:extend, Delayed::DelayMail)
-      end
-    end
-
-    rake_tasks do
-      load 'delayed/tasks.rb'
-    end
-  end
-end

data/lib/delayed/recipes.rb

@@ -1,50 +0,0 @@
-# Capistrano Recipes for managing delayed_job
-#
-# Add these callbacks to have the delayed_job process restart when the server
-# is restarted:
-#
-#   after "deploy:stop",    "delayed_job:stop"
-#   after "deploy:start",   "delayed_job:start"
-#   after "deploy:restart", "delayed_job:restart"
-#
-# If you want to use command line options, for example to start multiple workers,
-# define a Capistrano variable delayed_job_args:
-#
-#   set :delayed_job_args, "-n 2"
-#
-# If you've got delayed_job workers running on a servers, you can also specify
-# which servers have delayed_job running and should be restarted after deploy.
-#
-#   set :delayed_job_server_role, :worker
-#
-
-Capistrano::Configuration.instance.load do
-  namespace :delayed_job do
-    def rails_env
-      fetch(:rails_env, false) ? "RAILS_ENV=#{fetch(:rails_env)}" : ''
-    end
-    
-    def args
-      fetch(:delayed_job_args, "")
-    end
-    
-    def roles
-      fetch(:delayed_job_server_role, :app)
-    end
-    
-    desc "Stop the delayed_job process"
-    task :stop, :roles => lambda { roles } do
-      run "cd #{current_path};#{rails_env} script/delayed_job stop"
-    end
-
-    desc "Start the delayed_job process"
-    task :start, :roles => lambda { roles } do
-      run "cd #{current_path};#{rails_env} script/delayed_job start #{args}"
-    end
-
-    desc "Restart the delayed_job process"
-    task :restart, :roles => lambda { roles } do
-      run "cd #{current_path};#{rails_env} script/delayed_job restart #{args}"
-    end
-  end
-end