Rails 4.2 ottiene un ID lavoro ritardato dal lavoro attivo

Question

Qualche idea su come ottenere l'ID Delayed::Job da ActiveJob per l'accodamento? Quando accodico un lavoro torno a un'istanza di ActiveJob::Base con un @job_id, ma quell'ID lavoro sembra essere interno a ActiveJob. La mia ipotesi migliore è finora solo camminare per i posti di lavoro di più recente istituzione:

active_job_id = GenerateReportJob.perform_later(self.id).job_id 
delayed_job = Delayed::Job.order(id: :desc).limit(5).detect do |job| 
    YAML.load(job.handler).job_data['job_id'] == active_job_id 
end 

ma che sembra tutti i tipi di hacky. Un po 'sorpreso ActiveJob non restituisce l'ID da Delayed::Job, soprattutto perché è ciò che viene esplicitamente restituito quando il lavoro viene messo in coda.

== EDIT

Sembra che io non sono l'unico (https://github.com/rails/rails/issues/18821)

Answer 1

Nel caso in cui qualcuno trova questo in futuro: Rails appena accettato una patch per consentire di ottenere questo id da provider_job_id in Rails 5. È possibile farlo funzionare con una patch come

ActiveJob::QueueAdapters::DelayedJobAdapter.singleton_class.prepend(Module.new do 
    def enqueue(job) 
    provider_job = super 
    job.provider_job_id = provider_job.id 
    provider_job 
    end 

    def enqueue_at(job, timestamp) 
    provider_job = super 
    job.provider_job_id = provider_job.id 
    provider_job 
    end 
end) 

Answer 2

Invece di rimuovere il processo dalla coda, se viene annullata si potrebbe modellare una cancellazione del lavoro stesso.

Quindi, quando si arriva a eseguire il GenerateReportJob è possibile prima verificare la cancellazione del rapporto. Se ce n'è uno, puoi distruggere il record di cancellazione e abbandonare la generazione del rapporto. Se non ci sono cancellazioni, puoi continuare normalmente.

Answer 3

ho fatto funziona in Rails 4.2 utilizzando la nuova patch da Rails 5 in questo modo:

creare il file lib/active_job/queue_adapters/delayed_job_adapter.rb

module ActiveJob 
    module QueueAdapters 
    class DelayedJobAdapter 
     class << self 
     def enqueue(job) #:nodoc: 
      delayed_job = Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name) 
      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, run_at: Time.at(timestamp)) 
      job.provider_job_id = delayed_job.id 
      delayed_job 
     end 
     end 

     class JobWrapper #:nodoc: 
     attr_accessor :job_data 

     def initialize(job_data) 
      @job_data = job_data 
     end 

     def perform 
      Base.execute(job_data) 
     end 
     end 
    end 
    end 
end 

Answer 4

Ispirato alla risposta di Beguené e qualche rovescio engineering del codice ActiveJob Rails 5, ho fatto lavorare con Rails 4.2 da

1) aggiungendo seguente codice nel lib/active_job/queue_adapters/delayed_job_adapter.rb o config/initializers/delayed_job.rb (entrambe le posizioni hanno lavorato):

# file: lib/active_job/queue_adapters/delayed_job_adapter.rb 
module ActiveJob 
    module Core 
    # ID optionally provided by adapter 
    attr_accessor :provider_job_id 
    end 

    module QueueAdapters 
    class DelayedJobAdapter 
     class << self 
     def enqueue(job) #:nodoc: 
      delayed_job = Delayed::Job.enqueue(JobWrapper.new(job.serialize), queue: job.queue_name) 
      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, run_at: Time.at(timestamp)) 
      job.provider_job_id = delayed_job.id 
      delayed_job 
     end 
     end 
     class JobWrapper #:nodoc: 
     attr_accessor :job_data 

     def initialize(job_data) 
      @job_data = job_data 
     end 

     def perform 
      Base.execute(job_data) 
     end 
     end 
    end 
    end 
end 

La dichiarazione attr_accessor :provider_job_id è necessario in Rails 4.2, poiché è utilizzato nel metodo di accodamento e non è ancora definito in 4.2.

Poi possiamo fare uso di esso come segue:

2) definire la nostra propria classe ActiveJob:

# file: app/jobs/my_job.rb 
class MyJob < ActiveJob::Base 
    queue_as :default 

    def perform(object, performmethod = method(:method)) 
    # Do something later 
     returnvalue = object.send(performmethod) 
     returnvalue 
    end 

    end 
end 

3) Ora possiamo creare un nuovo lavoro in qualsiasi parte del codice:

job = MyJob.perform_later(Myobject, "mymethod") 

Inserirà il metodo Myobject.mymethod nella coda.

4) Il codice in 1) ci aiuta a trovare il lavoro in ritardo che è associato con il nostro lavoro:

delayed_job = Delayed::Job.find(job.provider_job_id) 

5), infine, si può fare, tutto ciò che dobbiamo fare con il delayed_job, per esempioeliminarlo:

delayed_job.delete 

Nota: in Rails 5, punto 1) non sarà più necessario, dal momento che lo stesso codice esatto è parte integrante di Rails 5.