For example, the web server needs to respond in less than 30 seconds, while an API importing his/her data might need to take 5 minutes. Have you ever needed to test which jobs were enqueued or performed when executing some specs? There’s a good change you were using test helpers provided by ActiveJob or rspec-activejob for that.In request-response model server usually has very short time to run transactions, and thus it doesn't have enough time to handle time-consuming jobs. execute ( job_data ) end end end TestAdapter id delayed_job end class JobWrapper #:nodoc: attr_accessor :job_data def initialize ( job_data ) = job_data end def perform Base. id delayed_job end def enqueue_at ( job, timestamp ) #:nodoc: delayed_job = Delayed :: Job. # activejob/queue_adatpers/delayed_job_adapter.rb class DelayedJobAdapter def enqueue ( job ) #:nodoc: delayed_job = Delayed :: Job. At the end, the internal job id from DelayedJob’s queue is assigned to provider_job_id attribute: Just like SidekiqAdapter, it wraps serialized job with internal JobWrapper instance which delegates execution of the logic to ActiveJob::Base.execute. The pattern is exactly the same as for Sidekiq Adapter: We have enqueue and enqueue_at methods and both of them push the job to the queue with extra info about queue name, priority and, for enqueue_at method, the time to run the job at.
Let’s take a look at adapter for arguably most common choice backed by application’s database - DelayedJob. Pushing a job to Sidekiq queue returns internal job id which is then assigned to provider_job_id attribute. As an extra argument, enqueue_at passes timestamp for executing the job at specific time. execute job_data end end endĪgain, like every other adapter, SidekiqAdapter implements enqueue and enqueue_at methods and both of them push jobs to Sidekiq’s queue by passing some meta info that is later used for identifying proper job class, executing in specific queue and of course the serialized arguments. queue_name, 'args' =>, 'at' => timestamp end class JobWrapper #:nodoc: include Sidekiq :: Worker def perform ( job_data ) Base. push \ 'class' => JobWrapper, 'wrapped' => job. queue_name, 'args' => end def enqueue_at ( job, timestamp ) #:nodoc: job. # activejob/queue_adapters/sidekiq_adapter.rb class SidekiqAdapter def enqueue ( job ) #:nodoc: #Sidekiq::Client does not support symbols as keys job. For Async adapter, these methods simply pass instance of JobWrapper with queue_name and timestamp (only for enqueue_at): The primary interface that is required for all queue adapters to implement is two methods: enqueue and enqueue_at. Let’s get back to top-level AsyncAdapter class. The main difference between these two methods is a timestamp (or lack of it) used for executing the job later. wait_for_termination if wait end def executor immediate ? : end end end end end
execute ( delay, args:, executor: executor, & :perform ) else enqueue ( job, queue_name: queue_name ) end end def shutdown ( wait: true ). to_f if delay > 0 Concurrent :: ScheduledTask. post ( job, & :perform ) end def enqueue_at ( job, timestamp, queue_name :) delay = timestamp - Time. merge ( options )) end def enqueue ( job, queue_name :) executor. immediate = false = Concurrent :: ImmediateExecutor. freeze attr_accessor :immediate def initialize ( ** options ) self. # active_job/configured_job.rb module ActiveJob class ConfiguredJob #:nodoc: def initialize ( job_class, options =.
0 kommentar(er)
