Module: RabbitJobs::Job

Extended by:
Helpers, Job
Included in:
Job
Defined in:
lib/rabbit_jobs/job.rb

Defined Under Namespace

Modules: ClassMethods

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Helpers

constantize, symbolize_keys!

Class Method Details

.included(base) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/rabbit_jobs/job.rb', line 9

def self.included(base)
  base.extend (ClassMethods)

  def initialize(*perform_params)
    self.params = perform_params
    self.opts = {}
  end

  attr_accessor :params, :opts

  def run_perform
    begin
      start_time = Time.now
      RJ.logger.info "Started to perform #{self.to_ruby_string}"
      self.class.perform(*params)
      execution_time = Time.now - start_time
      RJ.logger.info "     Job completed #{self.to_ruby_string} in #{execution_time} seconds."
    rescue
      RJ.logger.warn $!.message
      RJ.logger.warn(self.to_ruby_string)
      RJ.logger.warn RJ::Util.cleanup_backtrace($!.backtrace).join("\n")
      run_on_error_hooks($!)
      RabbitJobs::ErrorMailer.report_error(self, $!)
    end
  end

  def run_on_error_hooks(error)
    if self.class.rj_on_error_hooks
      self.class.rj_on_error_hooks.each do |proc_or_symbol|
        proc = proc_or_symbol
        if proc_or_symbol.is_a?(Symbol)
          proc = self.method(proc_or_symbol)
        end

        case proc.arity
        when 0
          proc.call()
        when 1
          proc.call(error)
        else
          proc.call(error, *params)
        end
      end
    end
  end

  def payload
    {'class' => self.class.to_s, 'opts' => (self.opts || {}), 'params' => params}.to_json
  end

  def expires_in
    self.class.rj_expires_in
  end

  def expires?
    self.expires_in && self.expires_in > 0
  end

  def expired?
    if self.opts['expires_at']
      Time.now.to_i > opts['expires_at'].to_i
    elsif expires? && opts['created_at']
      Time.now.to_i > (opts['created_at'].to_i + expires_in.to_i)
    else
      false
    end
  end

  def to_ruby_string
    rs = self.class.name
    if params.count > 0
      rs << "("
        rs << params.map(&:to_s).join(", ")
      rs << ")"
    end
    if opts.count > 0
      rs << ", opts: "
      rs << opts.inspect
    end
  end
end

.parse(payload) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/rabbit_jobs/job.rb', line 108

def self.parse(payload)
  begin
    encoded = JSON.parse(payload)
    job_klass = constantize(encoded['class'])
    job = job_klass.new(*encoded['params'])
    job.opts = encoded['opts']
    job
  rescue NameError
    RJ.logger.error "Cannot find job class '#{encoded['class']}'"
    :not_found
  rescue JSON::ParserError
    RJ.logger.error "Cannot initialize job. Json parsing error."
    RJ.logger.error "Data received: #{payload.inspect}"
    :parsing_error
  rescue
    RJ.logger.warn "Cannot initialize job."
    RJ.logger.warn $!.message
    RJ.logger.warn RJ::Util.cleanup_backtrace($!.backtrace).join("\n")
    RJ.logger.warn "Data received: #{payload.inspect}"
    :error
  end
end

Instance Method Details

#expired? ⇒ Boolean

Returns:

  • (Boolean) 


67
68
69
70
71
72
73
74
75
 
# File 'lib/rabbit_jobs/job.rb', line 67

def expired?
  if self.opts['expires_at']
    Time.now.to_i > opts['expires_at'].to_i
  elsif expires? && opts['created_at']
    Time.now.to_i > (opts['created_at'].to_i + expires_in.to_i)
  else
    false
  end
end

#expires? ⇒ Boolean

Returns:

  • (Boolean) 


63
64
65
 
# File 'lib/rabbit_jobs/job.rb', line 63

def expires?
  self.expires_in && self.expires_in > 0
end

#expires_in ⇒ Object 



59
60
61
 
# File 'lib/rabbit_jobs/job.rb', line 59

def expires_in
  self.class.rj_expires_in
end

#initialize(*perform_params) ⇒ Object 



12
13
14
15
 
# File 'lib/rabbit_jobs/job.rb', line 12

def initialize(*perform_params)
  self.params = perform_params
  self.opts = {}
end

#payload ⇒ Object 



55
56
57
 
# File 'lib/rabbit_jobs/job.rb', line 55

def payload
  {'class' => self.class.to_s, 'opts' => (self.opts || {}), 'params' => params}.to_json
end

#run_on_error_hooks(error) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/rabbit_jobs/job.rb', line 35

def run_on_error_hooks(error)
  if self.class.rj_on_error_hooks
    self.class.rj_on_error_hooks.each do |proc_or_symbol|
      proc = proc_or_symbol
      if proc_or_symbol.is_a?(Symbol)
        proc = self.method(proc_or_symbol)
      end

      case proc.arity
      when 0
        proc.call()
      when 1
        proc.call(error)
      else
        proc.call(error, *params)
      end
    end
  end
end

#run_perform ⇒ Object 



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/rabbit_jobs/job.rb', line 19

def run_perform
  begin
    start_time = Time.now
    RJ.logger.info "Started to perform #{self.to_ruby_string}"
    self.class.perform(*params)
    execution_time = Time.now - start_time
    RJ.logger.info "     Job completed #{self.to_ruby_string} in #{execution_time} seconds."
  rescue
    RJ.logger.warn $!.message
    RJ.logger.warn(self.to_ruby_string)
    RJ.logger.warn RJ::Util.cleanup_backtrace($!.backtrace).join("\n")
    run_on_error_hooks($!)
    RabbitJobs::ErrorMailer.report_error(self, $!)
  end
end

#to_ruby_string ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/rabbit_jobs/job.rb', line 77

def to_ruby_string
  rs = self.class.name
  if params.count > 0
    rs << "("
      rs << params.map(&:to_s).join(", ")
    rs << ")"
  end
  if opts.count > 0
    rs << ", opts: "
    rs << opts.inspect
  end
end