Class: BackgroundWorker::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/background_worker/base.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Base

Returns a new instance of Base.



5
6
7
8
9
10
11
12
13
14
 
# File 'lib/background_worker/base.rb', line 5

def initialize(options = {})
  Time.zone = Setting.time_zone

  @uid = options['uid']

  # Store state persistently, to enable status checkups & progress reporting
  @state = BackgroundWorker::PersistentState.new(@uid, options.except('uid'))
  log("Created #{self.class}")
  log("Options are: #{options.pretty_inspect}")
end

Instance Attribute Details

#state ⇒ Object

Returns the value of attribute state.



3
4
5
 
# File 'lib/background_worker/base.rb', line 3

def state
  @state
end

#uid ⇒ Object

Returns the value of attribute uid.



3
4
5
 
# File 'lib/background_worker/base.rb', line 3

def uid
  @uid
end

Class Method Details

.get_state_of(worker_id) ⇒ Object 



54
55
56
 
# File 'lib/background_worker/base.rb', line 54

def get_state_of(worker_id)
  BackgroundWorker::PersistentState.get_state_of(worker_id)
end

.perform(method_name, options = {}) ⇒ Object

This method is called by the job runner

It will just call your preferred method in the worker.



75
76
77
78
79
80
81
82
83
 
# File 'lib/background_worker/base.rb', line 75

def perform(method_name, options = {})
  BackgroundWorker.verify_active_connections!


  worker = new(options)
  execution = WorkerExecution.new(worker, method_name, options)
  execution.call

end

.perform_in_background(method_name, options = {}) ⇒ Object

Public method to do in background…



59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/background_worker/base.rb', line 59

def perform_in_background(method_name, options = {})
  method_name = method_name.to_sym
  options[:uid] ||= BackgroundWorker::Uid.new(to_s, method_name).generate

  # Store into shared-cache before kicking job off
  BackgroundWorker::PersistentState.new(options[:uid], options.except(:uid))

  # Enqueue to the background queue
  BackgroundWorker.enqueue(self, method_name, options)

  options[:uid]
end

Instance Method Details

#log(message, options = {}) ⇒ Object 



48
49
50
51
 
# File 'lib/background_worker/base.rb', line 48

def log(message, options = {})
  severity = options.fetch(:severity, :info)
  logger.send(severity, "uid=#{uid} #{message}")
end

#logger ⇒ Object 



44
45
46
 
# File 'lib/background_worker/base.rb', line 44

def logger
  BackgroundWorker.logger
end

#report_failed(message = 'Failed', detailed_message = nil) ⇒ Object 



39
40
41
42
 
# File 'lib/background_worker/base.rb', line 39

def report_failed(message = 'Failed', detailed_message = nil)
  state.detailed_message = detailed_message
  state.set_completed(message, :failed)
end

#report_minor_progress(message) ⇒ Object

Report a minor progress – may get called a lot, so don’t save it so often



23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/background_worker/base.rb', line 23

def report_minor_progress(message)
  state.message = message

  # Only report minor events once per second
  @last_report ||= Time.now - 2
  time_elapsed =  Time.now - @last_report
  return unless time_elapsed > 1

  @last_report = Time.now
  state.save
end

#report_progress(message) ⇒ Object

Report progress…



17
18
19
20
 
# File 'lib/background_worker/base.rb', line 17

def report_progress(message)
  state.message = message
  state.save
end

#report_successful(message = 'Finished successfully') ⇒ Object 



35
36
37
 
# File 'lib/background_worker/base.rb', line 35

def report_successful(message = 'Finished successfully')
  state.set_completed(message, :successful)
end