que 0.11.3 → 2.2.0

data/lib/que/job_methods.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Que
+  SQL[:finish_job] =
+    %{
+      UPDATE public.que_jobs
+      SET finished_at = now()
+      WHERE id = $1::bigint
+    }
+
+  SQL[:expire_job] =
+    %{
+      UPDATE public.que_jobs
+      SET error_count = error_count + 1,
+          expired_at = now()
+      WHERE id = $1::bigint
+    }
+
+  SQL[:destroy_job] =
+    %{
+      DELETE FROM public.que_jobs
+      WHERE id = $1::bigint
+    }
+
+  SQL[:set_error] =
+    %{
+      UPDATE public.que_jobs
+      SET error_count          = error_count + 1,
+          run_at               = now() + $1::float * '1 second'::interval,
+          last_error_message   = left($2::text, 500),
+          last_error_backtrace = left($3::text, 10000)
+      WHERE id = $4::bigint
+    }
+
+  module JobMethods
+    # Note that we delegate almost all methods to the result of the que_target
+    # method, which could be one of a few things, depending on the circumstance.
+
+    # Run the job with error handling and cleanup logic. Optionally support
+    # overriding the args, because it's necessary when jobs are invoked from
+    # ActiveJob.
+    def _run(args: nil, kwargs: nil, reraise_errors: false)
+      if args.nil? && que_target
+        args = que_target.que_attrs.fetch(:args)
+      end
+
+      if kwargs.nil? && que_target
+        kwargs = que_target.que_attrs.fetch(:kwargs)
+      end
+
+      run(*args, **kwargs)
+      default_resolve_action if que_target && !que_target.que_resolved
+    rescue => error
+      raise error unless que_target
+
+      que_target.que_error = error
+
+      run_error_notifier =
+        begin
+          handle_error(error)
+        rescue => error_2
+          Que.notify_error(error_2, que_target.que_attrs)
+          true
+        end
+
+      Que.notify_error(error, que_target.que_attrs) if run_error_notifier
+      retry_in_default_interval unless que_target.que_resolved
+
+      raise error if reraise_errors
+    end
+
+    def log_level(elapsed)
+      :debug
+    end
+
+    private
+
+    # This method defines the object on which the various job helper methods are
+    # acting. When using Que in the default configuration this will just be
+    # self, but when using the Que adapter for ActiveJob it'll be the actual
+    # underlying job object. When running an ActiveJob::Base subclass that
+    # includes this module through a separate adapter this will be nil - hence,
+    # the defensive coding in every method that no-ops if que_target is falsy.
+    def que_target
+      raise NotImplementedError
+    end
+
+    def resolve_que_setting(*args)
+      return unless que_target
+
+      que_target.class.resolve_que_setting(*args)
+    end
+
+    def default_resolve_action
+      return unless que_target
+
+      destroy
+    end
+
+    def expire
+      return unless que_target
+
+      if id = que_target.que_attrs[:id]
+        Que.execute :expire_job, [id]
+      end
+
+      que_target.que_resolved = true
+    end
+
+    def finish
+      return unless que_target
+
+      if id = que_target.que_attrs[:id]
+        Que.execute :finish_job, [id]
+      end
+
+      que_target.que_resolved = true
+    end
+
+    def error_count
+      return 0 unless que_target
+
+      count = que_target.que_attrs.fetch(:error_count)
+      que_target.que_error ? count + 1 : count
+    end
+
+    # To be overridden in subclasses.
+    def handle_error(error)
+      return unless que_target
+
+      max = resolve_que_setting(:maximum_retry_count)
+
+      if max && error_count > max
+        expire
+      else
+        retry_in_default_interval
+      end
+    end
+
+    def retry_in_default_interval
+      return unless que_target
+
+      retry_in(resolve_que_setting(:retry_interval, error_count))
+    end
+
+    # Explicitly check for the job id in these helpers, because it won't exist
+    # if we're running synchronously.
+    def retry_in(period)
+      return unless que_target
+
+      if id = que_target.que_attrs[:id]
+        values = [period]
+
+        if e = que_target.que_error
+          values << "#{e.class}: #{e.message}".slice(0, 500) << e.backtrace.join("\n").slice(0, 10000)
+        else
+          values << nil << nil
+        end
+
+        Que.execute :set_error, values << id
+      end
+
+      que_target.que_resolved = true
+    end
+
+    def destroy
+      return unless que_target
+
+      if id = que_target.que_attrs[:id]
+        Que.execute :destroy_job, [id]
+      end
+
+      que_target.que_resolved = true
+    end
+  end
+end

data/lib/que/listener.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Que
+  class Listener
+    MESSAGE_FORMATS = {}
+
+    attr_reader :connection, :channel
+
+    def initialize(connection:, channel: nil)
+      @connection = connection
+      @channel    = channel || "que_listener_#{connection.backend_pid}"
+
+      Que.internal_log :listener_instantiate, self do
+        {
+          backend_pid: connection.backend_pid,
+        }
+      end
+    end
+
+    def listen
+      connection.execute "LISTEN #{channel}"
+    end
+
+    def wait_for_grouped_messages(timeout)
+      messages = wait_for_messages(timeout)
+
+      output = {}
+
+      messages.each do |message|
+        message_type = message.delete(:message_type)
+
+        (output[message_type.to_sym] ||= []) << message.freeze
+      end
+
+      output
+    end
+
+    def wait_for_messages(timeout)
+      # Make sure we never pass nil to this method, so we don't hang the thread.
+      Que.assert(Numeric, timeout)
+
+      Que.internal_log :listener_waiting, self do
+        {
+          backend_pid: connection.backend_pid,
+          channel:     channel,
+          timeout:     timeout,
+        }
+      end
+
+      accumulated_messages = []
+
+      # Notifications often come in batches (especially when a transaction that
+      # inserted many jobs commits), so we want to loop and pick up all the
+      # received notifications before continuing.
+      loop do
+        notification_received =
+          connection.wait_for_notify(timeout) do |channel, pid, payload|
+            # We've received a notification, so zero out the timeout before we
+            # loop again to check for another message. This ensures that we
+            # don't wait an additional `timeout` seconds after processing the
+            # final message before this method returns.
+            timeout = 0
+
+            Que.internal_log(:listener_received_notification, self) do
+              {
+                channel:     channel,
+                backend_pid: connection.backend_pid,
+                source_pid:  pid,
+                payload:     payload,
+              }
+            end
+
+            # Be very defensive about the message we receive - it may not be
+            # valid JSON or have the structure we expect.
+            next unless message = parse_payload(payload)
+
+            case message
+            when Array then accumulated_messages.concat(message)
+            when Hash  then accumulated_messages << message
+            else raise Error, "Unexpected parse_payload output: #{message.class}"
+            end
+          end
+
+        break unless notification_received
+      end
+
+      return accumulated_messages if accumulated_messages.empty?
+
+      Que.internal_log(:listener_received_messages, self) do
+        {
+          backend_pid: connection.backend_pid,
+          channel:     channel,
+          messages:    accumulated_messages,
+        }
+      end
+
+      accumulated_messages.keep_if do |message|
+        next unless message.is_a?(Hash)
+        next unless type = message[:message_type]
+        next unless type.is_a?(String)
+        next unless format = MESSAGE_FORMATS[type.to_sym]
+
+        if message_matches_format?(message, format)
+          true
+        else
+          error_message = [
+            "Message of type '#{type}' doesn't match format!",
+            # Massage message and format a bit to make these errors more readable.
+            "Message: #{Hash[message.reject{|k,v| k == :message_type}.sort_by{|k,v| k}].inspect}",
+            "Format: #{Hash[format.sort_by{|k,v| k}].inspect}",
+          ].join("\n")
+
+          Que.notify_error_async(Error.new(error_message))
+          false
+        end
+      end
+
+      Que.internal_log(:listener_filtered_messages, self) do
+        {
+          backend_pid: connection.backend_pid,
+          channel:     channel,
+          messages:    accumulated_messages,
+        }
+      end
+
+      accumulated_messages
+    end
+
+    def unlisten
+      # Be sure to drain all notifications so that any code that uses this
+      # connection later doesn't receive any nasty surprises.
+      connection.execute "UNLISTEN *"
+      connection.drain_notifications
+
+      Que.internal_log :listener_unlisten, self do
+        {
+          backend_pid: connection.backend_pid,
+          channel:     channel,
+        }
+      end
+    end
+
+    private
+
+    def parse_payload(payload)
+      Que.deserialize_json(payload)
+    rescue JSON::ParserError => e
+      Que.notify_error_async(e)
+      nil
+    end
+
+    def message_matches_format?(message, format)
+      message_has_all_keys?(message, format) &&
+        message_has_no_excess_keys?(message, format) &&
+        message_keys_all_valid?(message, format)
+    end
+
+    def message_has_all_keys?(message, format)
+      format.all? { |k,v| message.has_key?(k) }
+    end
+
+    def message_has_no_excess_keys?(message, format)
+      message.all? { |k,v| format.has_key?(k) || k == :message_type }
+    end
+
+    def message_keys_all_valid?(message, format)
+      message.all? do |key, value|
+        if type = format[key]
+          Que.assert?(type, value)
+        else
+          true
+        end
+      end
+    end
+  end
+end