activejob 5.2.3

data/lib/active_job/queue_adapters/backburner_adapter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "backburner"
+
+module ActiveJob
+  module QueueAdapters
+    # == Backburner adapter for Active Job
+    #
+    # Backburner is a beanstalkd-powered job queue that can handle a very
+    # high volume of jobs. You create background jobs and place them on
+    # multiple work queues to be processed later. Read more about
+    # Backburner {here}[https://github.com/nesquena/backburner].
+    #
+    # To use Backburner set the queue_adapter config to +:backburner+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :backburner
+    class BackburnerAdapter
+      def enqueue(job) #:nodoc:
+        Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name
+      end
+
+      def enqueue_at(job, timestamp) #:nodoc:
+        delay = timestamp - Time.current.to_f
+        Backburner::Worker.enqueue JobWrapper, [ job.serialize ], queue: job.queue_name, delay: delay
+      end
+
+      class JobWrapper #:nodoc:
+        class << self
+          def perform(job_data)
+            Base.execute job_data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/delayed_job_adapter.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "delayed_job"
+
+module ActiveJob
+  module QueueAdapters
+    # == Delayed Job adapter for Active Job
+    #
+    # Delayed::Job (or DJ) encapsulates the common pattern of asynchronously
+    # executing longer tasks in the background. Although DJ can have many
+    # storage backends, one of the most used is based on Active Record.
+    # Read more about Delayed Job {here}[https://github.com/collectiveidea/delayed_job].
+    #
+    # To use Delayed Job, set the queue_adapter config to +:delayed_job+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :delayed_job
+    class DelayedJobAdapter
+      def enqueue(job) #:nodoc:
+        delayed_job = Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name, priority: job.priority)
+        job.provider_job_id = delayed_job.id
+        delayed_job
+      end
+
+      def enqueue_at(job, timestamp) #:nodoc:
+        delayed_job = Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name, priority: job.priority, run_at: Time.at(timestamp))
+        job.provider_job_id = delayed_job.id
+        delayed_job
+      end
+
+      class JobWrapper #:nodoc:
+        attr_accessor :job_data
+
+        def initialize(job_data)
+          @job_data = job_data
+        end
+
+        def display_name
+          "#{job_data['job_class']} [#{job_data['job_id']}] from DelayedJob(#{job_data['queue_name']}) with arguments: #{job_data['arguments']}"
+        end
+
+        def perform
+          Base.execute(job_data)
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/inline_adapter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module QueueAdapters
+    # == Active Job Inline adapter
+    #
+    # When enqueuing jobs with the Inline adapter the job will be executed
+    # immediately.
+    #
+    # To use the Inline set the queue_adapter config to +:inline+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :inline
+    class InlineAdapter
+      def enqueue(job) #:nodoc:
+        Base.execute(job.serialize)
+      end
+
+      def enqueue_at(*) #:nodoc:
+        raise NotImplementedError, "Use a queueing backend to enqueue jobs in the future. Read more at http://guides.rubyonrails.org/active_job_basics.html"
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/qu_adapter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "qu"
+
+module ActiveJob
+  module QueueAdapters
+    # == Qu adapter for Active Job
+    #
+    # Qu is a Ruby library for queuing and processing background jobs. It is
+    # heavily inspired by delayed_job and Resque. Qu was created to overcome
+    # some shortcomings in the existing queuing libraries.
+    # The advantages of Qu are: Multiple backends (redis, mongo), jobs are
+    # requeued when worker is killed, resque-like API.
+    #
+    # Read more about Qu {here}[https://github.com/bkeepers/qu].
+    #
+    # To use Qu set the queue_adapter config to +:qu+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :qu
+    class QuAdapter
+      def enqueue(job, *args) #:nodoc:
+        qu_job = Qu::Payload.new(klass: JobWrapper, args: [job.serialize]).tap do |payload|
+          payload.instance_variable_set(:@queue, job.queue_name)
+        end.push
+
+        # qu_job can be nil depending on the configured backend
+        job.provider_job_id = qu_job.id unless qu_job.nil?
+        qu_job
+      end
+
+      def enqueue_at(job, timestamp, *args) #:nodoc:
+        raise NotImplementedError, "This queueing backend does not support scheduling jobs. To see what features are supported go to http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"
+      end
+
+      class JobWrapper < Qu::Job #:nodoc:
+        def initialize(job_data)
+          @job_data = job_data
+        end
+
+        def perform
+          Base.execute @job_data
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/que_adapter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "que"
+
+module ActiveJob
+  module QueueAdapters
+    # == Que adapter for Active Job
+    #
+    # Que is a high-performance alternative to DelayedJob or QueueClassic that
+    # improves the reliability of your application by protecting your jobs with
+    # the same ACID guarantees as the rest of your data. Que is a queue for
+    # Ruby and PostgreSQL that manages jobs using advisory locks.
+    #
+    # Read more about Que {here}[https://github.com/chanks/que].
+    #
+    # To use Que set the queue_adapter config to +:que+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :que
+    class QueAdapter
+      def enqueue(job) #:nodoc:
+        que_job = JobWrapper.enqueue job.serialize, priority: job.priority
+        job.provider_job_id = que_job.attrs["job_id"]
+        que_job
+      end
+
+      def enqueue_at(job, timestamp) #:nodoc:
+        que_job = JobWrapper.enqueue job.serialize, priority: job.priority, run_at: Time.at(timestamp)
+        job.provider_job_id = que_job.attrs["job_id"]
+        que_job
+      end
+
+      class JobWrapper < Que::Job #:nodoc:
+        def run(job_data)
+          Base.execute job_data
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/queue_classic_adapter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "queue_classic"
+
+module ActiveJob
+  module QueueAdapters
+    # == queue_classic adapter for Active Job
+    #
+    # queue_classic provides a simple interface to a PostgreSQL-backed message
+    # queue. queue_classic specializes in concurrent locking and minimizing
+    # database load while providing a simple, intuitive developer experience.
+    # queue_classic assumes that you are already using PostgreSQL in your
+    # production environment and that adding another dependency (e.g. redis,
+    # beanstalkd, 0mq) is undesirable.
+    #
+    # Read more about queue_classic {here}[https://github.com/QueueClassic/queue_classic].
+    #
+    # To use queue_classic set the queue_adapter config to +:queue_classic+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :queue_classic
+    class QueueClassicAdapter
+      def enqueue(job) #:nodoc:
+        qc_job = build_queue(job.queue_name).enqueue("#{JobWrapper.name}.perform", job.serialize)
+        job.provider_job_id = qc_job["id"] if qc_job.is_a?(Hash)
+        qc_job
+      end
+
+      def enqueue_at(job, timestamp) #:nodoc:
+        queue = build_queue(job.queue_name)
+        unless queue.respond_to?(:enqueue_at)
+          raise NotImplementedError, "To be able to schedule jobs with queue_classic " \
+            "the QC::Queue needs to respond to `enqueue_at(timestamp, method, *args)`. " \
+            "You can implement this yourself or you can use the queue_classic-later gem."
+        end
+        qc_job = queue.enqueue_at(timestamp, "#{JobWrapper.name}.perform", job.serialize)
+        job.provider_job_id = qc_job["id"] if qc_job.is_a?(Hash)
+        qc_job
+      end
+
+      # Builds a <tt>QC::Queue</tt> object to schedule jobs on.
+      #
+      # If you have a custom <tt>QC::Queue</tt> subclass you'll need to subclass
+      # <tt>ActiveJob::QueueAdapters::QueueClassicAdapter</tt> and override the
+      # <tt>build_queue</tt> method.
+      def build_queue(queue_name)
+        QC::Queue.new(queue_name)
+      end
+
+      class JobWrapper #:nodoc:
+        class << self
+          def perform(job_data)
+            Base.execute job_data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/resque_adapter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "resque"
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/array/access"
+
+begin
+  require "resque-scheduler"
+rescue LoadError
+  begin
+    require "resque_scheduler"
+  rescue LoadError
+    false
+  end
+end
+
+module ActiveJob
+  module QueueAdapters
+    # == Resque adapter for Active Job
+    #
+    # Resque (pronounced like "rescue") is a Redis-backed library for creating
+    # background jobs, placing those jobs on multiple queues, and processing
+    # them later.
+    #
+    # Read more about Resque {here}[https://github.com/resque/resque].
+    #
+    # To use Resque set the queue_adapter config to +:resque+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :resque
+    class ResqueAdapter
+      def enqueue(job) #:nodoc:
+        JobWrapper.instance_variable_set(:@queue, job.queue_name)
+        Resque.enqueue_to job.queue_name, JobWrapper, job.serialize
+      end
+
+      def enqueue_at(job, timestamp) #:nodoc:
+        unless Resque.respond_to?(:enqueue_at_with_queue)
+          raise NotImplementedError, "To be able to schedule jobs with Resque you need the " \
+            "resque-scheduler gem. Please add it to your Gemfile and run bundle install"
+        end
+        Resque.enqueue_at_with_queue job.queue_name, timestamp, JobWrapper, job.serialize
+      end
+
+      class JobWrapper #:nodoc:
+        class << self
+          def perform(job_data)
+            Base.execute job_data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/sidekiq_adapter.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "sidekiq"
+
+module ActiveJob
+  module QueueAdapters
+    # == Sidekiq adapter for Active Job
+    #
+    # Simple, efficient background processing for Ruby. Sidekiq uses threads to
+    # handle many jobs at the same time in the same process. It does not
+    # require Rails but will integrate tightly with it to make background
+    # processing dead simple.
+    #
+    # Read more about Sidekiq {here}[http://sidekiq.org].
+    #
+    # To use Sidekiq set the queue_adapter config to +:sidekiq+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :sidekiq
+    class SidekiqAdapter
+      def enqueue(job) #:nodoc:
+        # Sidekiq::Client does not support symbols as keys
+        job.provider_job_id = Sidekiq::Client.push \
+          "class"   => JobWrapper,
+          "wrapped" => job.class.to_s,
+          "queue"   => job.queue_name,
+          "args"    => [ job.serialize ]
+      end
+
+      def enqueue_at(job, timestamp) #:nodoc:
+        job.provider_job_id = Sidekiq::Client.push \
+          "class"   => JobWrapper,
+          "wrapped" => job.class.to_s,
+          "queue"   => job.queue_name,
+          "args"    => [ job.serialize ],
+          "at"      => timestamp
+      end
+
+      class JobWrapper #:nodoc:
+        include Sidekiq::Worker
+
+        def perform(job_data)
+          Base.execute job_data.merge("provider_job_id" => jid)
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/sneakers_adapter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "sneakers"
+require "monitor"
+
+module ActiveJob
+  module QueueAdapters
+    # == Sneakers adapter for Active Job
+    #
+    # A high-performance RabbitMQ background processing framework for Ruby.
+    # Sneakers is being used in production for both I/O and CPU intensive
+    # workloads, and have achieved the goals of high-performance and
+    # 0-maintenance, as designed.
+    #
+    # Read more about Sneakers {here}[https://github.com/jondot/sneakers].
+    #
+    # To use Sneakers set the queue_adapter config to +:sneakers+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :sneakers
+    class SneakersAdapter
+      def initialize
+        @monitor = Monitor.new
+      end
+
+      def enqueue(job) #:nodoc:
+        @monitor.synchronize do
+          JobWrapper.from_queue job.queue_name
+          JobWrapper.enqueue ActiveSupport::JSON.encode(job.serialize)
+        end
+      end
+
+      def enqueue_at(job, timestamp) #:nodoc:
+        raise NotImplementedError, "This queueing backend does not support scheduling jobs. To see what features are supported go to http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html"
+      end
+
+      class JobWrapper #:nodoc:
+        include Sneakers::Worker
+        from_queue "default"
+
+        def work(msg)
+          job_data = ActiveSupport::JSON.decode(msg)
+          Base.execute job_data
+          ack!
+        end
+      end
+    end
+  end
+end

data/lib/active_job/queue_adapters/sucker_punch_adapter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "sucker_punch"
+
+module ActiveJob
+  module QueueAdapters
+    # == Sucker Punch adapter for Active Job
+    #
+    # Sucker Punch is a single-process Ruby asynchronous processing library.
+    # This reduces the cost of hosting on a service like Heroku along
+    # with the memory footprint of having to maintain additional jobs if
+    # hosting on a dedicated server. All queues can run within a
+    # single application (eg. Rails, Sinatra, etc.) process.
+    #
+    # Read more about Sucker Punch {here}[https://github.com/brandonhilkert/sucker_punch].
+    #
+    # To use Sucker Punch set the queue_adapter config to +:sucker_punch+.
+    #
+    #   Rails.application.config.active_job.queue_adapter = :sucker_punch
+    class SuckerPunchAdapter
+      def enqueue(job) #:nodoc:
+        if JobWrapper.respond_to?(:perform_async)
+          # sucker_punch 2.0 API
+          JobWrapper.perform_async job.serialize
+        else
+          # sucker_punch 1.0 API
+          JobWrapper.new.async.perform job.serialize
+        end
+      end
+
+      def enqueue_at(job, timestamp) #:nodoc:
+        if JobWrapper.respond_to?(:perform_in)
+          delay = timestamp - Time.current.to_f
+          JobWrapper.perform_in delay, job.serialize
+        else
+          raise NotImplementedError, "sucker_punch 1.0 does not support `enqueued_at`. Please upgrade to version ~> 2.0.0 to enable this behavior."
+        end
+      end
+
+      class JobWrapper #:nodoc:
+        include SuckerPunch::Job
+
+        def perform(job_data)
+          Base.execute job_data
+        end
+      end
+    end
+  end
+end