resque-integration 3.4.1

data/lib/resque/integration/logs_rotator.rb

@@ -0,0 +1,95 @@
+# coding: utf-8
+module Resque
+  module Integration
+    class LogsRotator
+      class << self
+
+        # Перенаправить стандартный вывод в файл
+        def redirect_std
+          log_path = ::Resque.config.log_file
+          STDOUT.reopen File.open(log_path, 'a')
+          STDERR.reopen File.open(log_path, 'a')
+          STDOUT.sync = STDERR.sync = true
+        end
+
+        def register_hup_signal
+          Signal.trap('HUP') { ::Resque::Integration::LogsRotator.reopen_logs }
+        end
+
+        # Переоткрытие всех логов
+        #
+        # @see Unicorn::Utils
+        def reopen_logs
+          to_reopen = []
+          nr = 0
+          ObjectSpace.each_object(File) { |fp| is_log?(fp) and to_reopen << fp }
+
+          to_reopen.each do |fp|
+            orig_st = begin
+              fp.stat
+            rescue IOError, Errno::EBADF # race
+              next
+            end
+
+            begin
+              b = File.stat(fp.path)
+              next if orig_st.ino == b.ino && orig_st.dev == b.dev
+            rescue Errno::ENOENT
+            end
+
+            begin
+              # stdin, stdout, stderr are special.  The following dance should
+              # guarantee there is no window where `fp' is unwritable in MRI
+              # (or any correct Ruby implementation).
+              #
+              # Fwiw, GVL has zero bearing here.  This is tricky because of
+              # the unavoidable existence of stdio FILE * pointers for
+              # std{in,out,err} in all programs which may use the standard C library
+              if fp.fileno <= 2
+                # We do not want to hit fclose(3)->dup(2) window for std{in,out,err}
+                # MRI will use freopen(3) here internally on std{in,out,err}
+                fp.reopen(fp.path, "a")
+              else
+                # We should not need this workaround, Ruby can be fixed:
+                #    http://bugs.ruby-lang.org/issues/9036
+                # MRI will not call call fclose(3) or freopen(3) here
+                # since there's no associated std{in,out,err} FILE * pointer
+                # This should atomically use dup3(2) (or dup2(2)) syscall
+                File.open(fp.path, "a") { |tmpfp| fp.reopen(tmpfp) }
+              end
+
+              fp.sync = true
+              fp.flush # IO#sync=true may not implicitly flush
+              new_st = fp.stat
+
+              # this should only happen in the master:
+              if orig_st.uid != new_st.uid || orig_st.gid != new_st.gid
+                fp.chown(orig_st.uid, orig_st.gid)
+              end
+
+              nr += 1
+            rescue IOError, Errno::EBADF
+              # not much we can do...
+            end
+          end
+          nr
+        end
+
+        private
+
+        # @see Unicorn::Utils
+        def is_log?(fp)
+          append_flags = File::WRONLY | File::APPEND
+
+          ! fp.closed? &&
+            fp.stat.file? &&
+            fp.sync &&
+            (fp.fcntl(Fcntl::F_GETFL) & append_flags) == append_flags
+          rescue IOError, Errno::EBADF
+            false
+        end
+
+      end
+    end
+  end
+end

data/lib/resque/integration/monkey_patch/verbose_formatter.rb

@@ -0,0 +1,10 @@
+require "resque/log_formatters/verbose_formatter"
+
+module Resque
+  class VerboseFormatter
+    def call(serverity, datetime, progname, msg)
+      time = Time.now.strftime('%H:%M:%S %Y-%m-%d')
+      "** [#{time}] #$$: #{msg}\n"
+    end
+  end
+end

data/lib/resque/integration/ordered.rb

@@ -0,0 +1,142 @@
+# Ordered Job
+#
+# Ensures that only one job for a given queue
+# will be running on any worker at a given time
+#
+# Examples:
+#
+#   class TestJob
+#     include Resque::Integration
+#
+#     unique { |company_id, param1| [company_id] }
+#     ordered max_iterations: 10
+#
+#     def self.execute(meta, company_id, param1)
+#       heavy_lifting_work
+#     end
+#   end
+#
+#   class UniqueTestJob
+#     include Resque::Integration
+#
+#     unique { |company_id, param1| [company_id] }
+#     ordered max_iterations: 10, unique: ->(_company_id, param1) { [param1] }
+#     ...
+#   end
+#
+module Resque
+  module Integration
+    module Ordered
+      ARGS_EXPIRATION = 1.week
+
+      def self.extended(base)
+        unless base.singleton_class.include?(::Resque::Integration::Unique)
+          base.extend ::Resque::Integration::Unique
+        end
+
+        unless base.singleton_class.include?(::Resque::Integration::Continuous)
+          base.extend ::Resque::Integration::Continuous
+        end
+
+        base.singleton_class.class_eval do
+          attr_accessor :max_iterations, :uniqueness
+
+          prepend Overrides
+        end
+      end
+
+      class Uniqueness
+        def initialize(&block)
+          @unique_block = block
+        end
+
+        def key(meta_id)
+          "ordered:unique:#{meta_id}"
+        end
+
+        def remove(meta_id, args)
+          Resque.redis.hdel(key(meta_id), encoded_unique_args(args))
+        end
+
+        def size(meta_id)
+          Resque.redis.hlen(key(meta_id)).to_i
+        end
+
+        def encoded_unique_args(args)
+          Resque.encode(@unique_block.call(*args))
+        end
+
+        def ordered_meta_id(meta_id, args)
+          Resque.redis.hget(key(meta_id), encoded_unique_args(args))
+        end
+
+        def set(meta_id, args, ordered_meta_id)
+          unique_key = key(meta_id)
+
+          if Resque.redis.hset(unique_key, encoded_unique_args(args), ordered_meta_id)
+            Resque.redis.expire(unique_key, ARGS_EXPIRATION)
+          end
+        end
+      end
+
+      module Overrides
+        def enqueue(*args)
+          meta = super
+
+          if uniqueness && ordered_meta_id = uniqueness.ordered_meta_id(meta.meta_id, args)
+            return get_meta(ordered_meta_id)
+          end
+
+          ordered_meta = ::Resque::Plugins::Meta::Metadata.new('meta_id' => ordered_meta_id(args), 'job_class' => self)
+          ordered_meta.save
+
+          uniqueness.set(meta.meta_id, args, ordered_meta.meta_id) if uniqueness
+          args.unshift(ordered_meta.meta_id)
+          encoded_args = ::Resque.encode(args)
+          args_key = ordered_queue_key(meta.meta_id)
+
+          ::Resque.redis.rpush(args_key, encoded_args)
+          ::Resque.redis.expire(args_key, ARGS_EXPIRATION)
+
+          ordered_meta
+        end
+
+        def perform(meta_id, *)
+          args_key = ordered_queue_key(meta_id)
+          i = 1
+          while job_args = ::Resque.redis.lpop(args_key)
+            job_args = ::Resque.decode(job_args)
+            ordered_meta = get_meta(job_args.shift)
+            ordered_meta.start!
+
+            begin
+              execute(ordered_meta, *job_args)
+            rescue Exception
+              ordered_meta.fail!
+              raise
+            ensure
+              uniqueness.remove(meta_id, job_args) if uniqueness
+            end
+
+            ordered_meta.finish!
+
+            i += 1
+            return continue if max_iterations && i > max_iterations && ordered_queue_size(meta_id) > 0
+          end
+        end
+      end
+
+      def ordered_queue_size(meta_id)
+        Resque.redis.llen(ordered_queue_key(meta_id)).to_i
+      end
+
+      def ordered_queue_key(meta_id)
+        "ordered:#{meta_id}"
+      end
+
+      def ordered_meta_id(args)
+        Digest::SHA1.hexdigest([Time.now.to_f, rand, self, args].join)
+      end
+    end
+  end
+end

data/lib/resque/integration/priority.rb

@@ -0,0 +1,89 @@
+module Resque
+  module Integration
+    # Public: job with priority queues
+    #
+    # Examples:
+    #   class MyJob
+    #     include Resque::Integration
+    #
+    #     queue :foo
+    #     prioritized
+    #
+    #     def self.perform(arg)
+    #       heavy_lifting_work
+    #     end
+    #   end
+    #
+    #   MyJob.enqueue_with_priority(:high, 1, another_param: 2) # enqueue job to :foo_high queue
+    #   MyJob.enqueue_with_priority(:low, 1, another_param: 2) # enqueue job to :foo_low queue
+    #
+    #   class MyUniqueJob
+    #     include Resque::Integration
+    #
+    #     queue :foo
+    #     unique
+    #     prioritized
+    #
+    #     def self.execute(*args)
+    #       meta = get_meta
+    #
+    #       heavy_lifting_work do
+    #         meta[:count] += 1
+    #       end
+    #     end
+    #   end
+    module Priority
+      def self.extended(base)
+        base.singleton_class.prepend(Overrides)
+      end
+
+      module Overrides
+        # Public: enqueue job with normal priority
+        #
+        # Example:
+        #   MyJob.enqueue(1)
+        def enqueue(*args)
+          enqueue_with_priority(:normal, *args)
+        end
+
+        # Public: dequeue job with priority
+        #
+        # Example:
+        #   MyJob.dequeue(:high, 1)
+        def dequeue(priority, *args)
+          if unique?
+            super(*args, priority)
+          else
+            Resque.dequeue(self, *args, priority)
+          end
+        end
+
+        def perform(*args, _priority)
+          super(*args)
+        end
+      end
+
+      def priority?
+        true
+      end
+
+      # Public: enqueue job to priority queue
+      #
+      # Example:
+      #   MyJob.enqueue_with_priority(:high, 1)
+      def enqueue_with_priority(priority, *args)
+        queue = priority_queue(priority)
+
+        if unique?
+          enqueue_to(queue, *args, priority)
+        else
+          Resque.enqueue_to(queue, self, *args, priority)
+        end
+      end
+
+      def priority_queue(priority)
+        priority.to_sym == :normal ? queue : "#{queue}_#{priority}".to_sym
+      end
+    end
+  end
+end

data/lib/resque/integration/queues_info/age.rb

@@ -0,0 +1,53 @@
+module Resque
+  module Integration
+    class QueuesInfo
+      class Age
+        def initialize(config)
+          @config = config
+        end
+
+        def time(queue)
+          from_time = Time.now.utc
+          max_secs = 0
+
+          jobs.each do |job|
+            next unless job['queue'] == queue
+            job_secs = seconds_for(job, from_time)
+            max_secs = job_secs if job_secs > max_secs
+          end
+
+          max_secs
+        end
+
+        def overall
+          from_time = Time.now.utc
+
+          max_secs = 0
+
+          jobs.each do |job|
+            next unless job['queue']
+            job_secs = seconds_for(job, from_time)
+            next if job_secs < threshold(job['queue'])
+            max_secs = job_secs if job_secs > max_secs
+          end
+
+          max_secs
+        end
+
+        def threshold(queue)
+          @config.max_age(queue)
+        end
+
+        private
+
+        def jobs
+          Resque.workers.each_with_object([]) { |worker, memo| memo << worker.job unless worker.idle? }
+        end
+
+        def seconds_for(job, from_time)
+          (from_time - DateTime.strptime(job['run_at'], '%Y-%m-%dT%H:%M:%S').utc).to_i
+        end
+      end
+    end
+  end
+end

data/lib/resque/integration/queues_info/config.rb

@@ -0,0 +1,96 @@
+require 'yaml'
+
+module Resque
+  module Integration
+    class QueuesInfo
+      class Config
+        def initialize(config_path)
+          config = load_config(config_path)
+          @defaults = config['defaults']
+          @queues = expand_config(config['queues'])
+        end
+
+        def max_age(queue)
+          threshold(queue, 'max_age')
+        end
+
+        def warn_age(queue)
+          threshold(queue, 'warn_age')
+        end
+
+        def max_size(queue)
+          threshold(queue, 'max_size')
+        end
+
+        def warn_size(queue)
+          threshold(queue, 'warn_size')
+        end
+
+        def max_failures_count(queue, period)
+          threshold(queue, "max_failures_count_per_#{period}")
+        end
+
+        def warn_failures_count(queue, period)
+          threshold(queue, "warn_failures_count_per_#{period}")
+        end
+
+        def channel(queue)
+          channel = threshold(queue, 'channel')
+          Array.wrap(channel).join(' ')
+        end
+
+        def warn_channel(queue)
+          channel = threshold(queue, 'warn_channel')
+          Array.wrap(channel).join(' ')
+        end
+
+        def data
+          @data ||= @queues.map do |queue_name, _queue_params|
+            {
+              '{#QUEUE}' => queue_name,
+
+              '{#CHANNEL}' => channel(queue_name),
+              '{#THRESHOLD_AGE}' => max_age(queue_name),
+              '{#THRESHOLD_SIZE}' => max_size(queue_name),
+              '{#THRESHOLD_FAILURES_PER_5M}' => max_failures_count(queue_name, '5m'),
+              '{#THRESHOLD_FAILURES_PER_1H}' => max_failures_count(queue_name, '1h'),
+
+              '{#WARNING_CHANNEL}' => warn_channel(queue_name),
+              '{#WARNING_AGE}' => warn_age(queue_name),
+              '{#WARNING_SIZE}' => warn_size(queue_name),
+              '{#WARNING_FAILURES_PER_5M}' => warn_failures_count(queue_name, '5m'),
+              '{#WARNING_FAILURES_PER_1H}' => warn_failures_count(queue_name, '1h')
+            }
+          end
+        end
+
+        private
+
+        def threshold(queue, param)
+          @queues[queue].try(:[], param) || @defaults[param]
+        end
+
+        def load_config(path)
+          input = File.read(path)
+          input = ERB.new(input).result if defined?(ERB)
+          YAML.load(input)
+        end
+
+        def expand_config(config)
+          expanded_config = {}
+
+          config.keys.each do |key|
+            key.split(',').each do |queue|
+              queue.chomp!
+              queue.strip!
+
+              (expanded_config[queue] ||= {}).merge!(config[key])
+            end
+          end
+
+          expanded_config
+        end
+      end
+    end
+  end
+end

data/lib/resque/integration/queues_info/size.rb

@@ -0,0 +1,33 @@
+module Resque
+  module Integration
+    class QueuesInfo
+      class Size
+        def initialize(config)
+          @config = config
+        end
+
+        def size(queue)
+          Resque.size(queue) || 0
+        end
+
+        def overall
+          max = 0
+
+          Resque.queues.each do |queue|
+            size = Resque.size(queue).to_i
+            next if size < threshold(queue)
+            max = size if size > max
+          end
+
+          max
+        end
+
+        private
+
+        def threshold(queue)
+          @config.max_size(queue)
+        end
+      end
+    end
+  end
+end

data/lib/resque/integration/queues_info.rb

@@ -0,0 +1,55 @@
+module Resque
+  module Integration
+    class QueuesInfo
+      autoload :Age, "resque/integration/queues_info/age"
+      autoload :Size, "resque/integration/queues_info/size"
+      autoload :Config, "resque/integration/queues_info/config"
+
+      def initialize(options)
+        @config = Config.new(options.fetch(:config))
+        @size = Size.new(@config)
+        @age = Age.new(@config)
+      end
+
+      def age_for_queue(queue)
+        @age.time(queue)
+      end
+
+      def age_overall
+        @age.overall
+      end
+
+      def size_for_queue(queue)
+        @size.size(queue)
+      end
+
+      def size_overall
+        @size.overall
+      end
+
+      def failures_count_for_queue(queue)
+        Resque::Integration::FailureBackends::QueuesTotals.count(queue)
+      end
+
+      def threshold_size(queue)
+        @config.max_size(queue)
+      end
+
+      def threshold_age(queue)
+        @config.max_age(queue)
+      end
+
+      def threshold_failures_count(queue, period)
+        @config.max_failures_count(queue, period)
+      end
+
+      def channel(queue)
+        @config.channel(queue)
+      end
+
+      def data
+        @config.data
+      end
+    end
+  end
+end

data/lib/resque/integration/tasks/hooks.rake

@@ -0,0 +1,49 @@
+# coding: utf-8
+require 'erb'
+
+namespace :resque do
+  # Здесь мы добавляем некоторые необходимые для корректной работы "хуки".
+  #
+  # @see https://github.com/resque/resque/tree/1-x-stable#workers
+  task :setup => :environment do
+    # принудительно инициализируем приложение
+    # (rails 3 не делают этого при запуске из rake-задачи)
+    Rails.application.eager_load! if Rails::VERSION::MAJOR < 4
+
+    # Включаем логирование в resque
+    ENV['VERBOSE'] = '1'
+
+    # перенаправление вывода в файл
+    Resque::Integration::LogsRotator.redirect_std
+    # слушать HUP сигнал для ротации логов
+    Resque::Integration::LogsRotator.register_hup_signal
+
+    # Нужно закрыть все соединения в **родительском** процессе,
+    # Нужно также закрыть соединение к memcache
+    Resque.before_first_fork do
+      ActiveRecord::Base.connection_handler.clear_all_connections!
+      Rails.cache.reset if Rails.cache.respond_to?(:reset)
+    end
+
+    Resque.before_fork do
+      Resque.redis.client.disconnect
+
+      ActiveRecord::Base.connection_handler.clear_all_connections!
+    end
+
+    Resque.after_fork do |job|
+      $0 = "resque-#{Resque::Version}: Processing #{job.queue}/#{job.payload['class']} since #{Time.now.to_s(:db)}"
+
+      ActiveRecord::Base.establish_connection
+
+      Resque.redis.client.connect
+    end
+
+    # Support for resque-multi-job-forks
+    require 'resque-multi-job-forks' if ENV['JOBS_PER_FORK'] || ENV['MINUTES_PER_FORK']
+
+    if Resque.config.run_at_exit_hooks? && ENV['RUN_AT_EXIT_HOOKS'].nil?
+      ENV['RUN_AT_EXIT_HOOKS'] = '1'
+    end
+  end
+end

data/lib/resque/integration/tasks/lock.rake

@@ -0,0 +1,37 @@
+require 'resque/integration/unique'
+
+namespace :resque do
+  namespace :lock do
+    task expire_all: :environment do
+      puts "Start expiring all resque locks"
+
+      redis = ::Resque.redis
+      cursor = 0
+      batch_size = 10_000
+      timeout = ::Resque::Integration::Unique::LOCK_TIMEOUT
+      count = 0
+      pattern = "lock:*"
+
+      loop do
+        cursor, keys = redis.scan(cursor, count: batch_size, match: pattern)
+        cursor = cursor.to_i
+
+        unless keys.empty?
+          redis.pipelined do
+            keys.each do |key|
+              redis.expire(key, timeout)
+            end
+          end
+
+          count += keys.size
+          puts "Expired #{count}..."
+        end
+
+        break if cursor.zero?
+      end
+
+      puts "Expired total #{count} keys."
+      puts "Done."
+    end
+  end
+end