Module: Dalliance

Extended by:
ActiveSupport::Concern
Defined in:
lib/dalliance.rb,
lib/dalliance/schema.rb,
lib/dalliance/railtie.rb,
lib/dalliance/version.rb,
lib/dalliance/workers.rb,
lib/dalliance/progress_meter.rb,
lib/dalliance/workers/resque.rb,
lib/dalliance/workers/delayed_job.rb,
lib/generators/dalliance/update/update_generator.rb,
lib/generators/dalliance/progress_meter/progress_meter_generator.rb

Defined Under Namespace

Modules: ClassMethods, Glue, Schema, VERSION, Workers Classes: ProgressMeter, ProgressMeterGenerator, Railtie, UpdateGenerator

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.background_processing=(value) ⇒ Object 



29
30
31
 
# File 'lib/dalliance.rb', line 29

def background_processing=(value)
  options[:background_processing] = value
end

.configure {|_self| ... } ⇒ Object

Yields:

  • (_self)

Yield Parameters:

  • _self (Dalliance) —

    the object that the method was called on



57
58
59
 
# File 'lib/dalliance.rb', line 57

def configure
  yield(self) if block_given?
end

.dalliance_progress_meter=(value) ⇒ Object 



33
34
35
 
# File 'lib/dalliance.rb', line 33

def dalliance_progress_meter=(value)
  options[:dalliance_progress_meter] = value
end

.dalliance_progress_meter_total_count_method=(value) ⇒ Object 



37
38
39
 
# File 'lib/dalliance.rb', line 37

def dalliance_progress_meter_total_count_method=(value)
  options[:dalliance_progress_meter_total_count_method] = value
end

.detect_logger ⇒ Object 



66
67
68
69
70
71
72
73
74
 
# File 'lib/dalliance.rb', line 66

def detect_logger
  if defined?(ActiveRecord)
    ActiveRecord::Base.logger
  elsif defined?(Rails)
    Rails.logger
  else
    ::Logger.new(STDOUT)
  end
end

.detect_worker_class ⇒ Object 



61
62
63
64
 
# File 'lib/dalliance.rb', line 61

def detect_worker_class
  return Dalliance::Workers::DelayedJob if defined? ::Delayed::Job
  return Dalliance::Workers::Resque     if defined? ::Resque
end

.duration_column=(value) ⇒ Object 



53
54
55
 
# File 'lib/dalliance.rb', line 53

def duration_column=(value)
  options[:duration_column] = value
end

.logger=(value) ⇒ Object 



49
50
51
 
# File 'lib/dalliance.rb', line 49

def logger=(value)
  options[:logger] = value
end

.options ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/dalliance.rb', line 17

def options
  @options ||= {
    :background_processing => (defined?(Rails) ? Rails.env.production? : true),
    :dalliance_progress_meter => true,
    :dalliance_progress_meter_total_count_method => :dalliance_progress_meter_total_count,
    :worker_class => detect_worker_class,
    :queue => 'dalliance',
    :logger => detect_logger,
    :duration_column => nil
  }
end

.queue=(value) ⇒ Object 



45
46
47
 
# File 'lib/dalliance.rb', line 45

def queue=(value)
  options[:queue] = value
end

.worker_class=(value) ⇒ Object 



41
42
43
 
# File 'lib/dalliance.rb', line 41

def worker_class=(value)
  options[:worker_class] = value
end

Instance Method Details

#calculate_dalliance_progress_meter_total_count ⇒ Object

If the progress_meter_total_count_method is not implemented just use 1…



190
191
192
193
194
195
196
 
# File 'lib/dalliance.rb', line 190

def calculate_dalliance_progress_meter_total_count
  if respond_to?(self.class.dalliance_options[:dalliance_progress_meter_total_count_method])
    self.send(self.class.dalliance_options[:dalliance_progress_meter_total_count_method])
  else
    1
  end
end

#dalliance_background_process(backgound_processing = nil) ⇒ Object

Force backgound_processing w/ true



128
129
130
131
132
133
134
 
# File 'lib/dalliance.rb', line 128

def dalliance_background_process(backgound_processing = nil)
  if backgound_processing || (backgound_processing.nil? && self.class.dalliance_options[:background_processing])
    self.class.dalliance_options[:worker_class].enqueue(self, self.class.dalliance_options[:queue])
  else
    dalliance_process(false)
  end
end

#dalliance_process(backgound_processing = false) ⇒ Object

backgound_processing == false will re-raise any exceptions



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/dalliance.rb', line 137

def dalliance_process(backgound_processing = false)
  start_time = Time.now

  begin
    start_dalliance!

    if self.class.dalliance_options[:dalliance_progress_meter]
      build_dalliance_progress_meter(:total_count => calculate_dalliance_progress_meter_total_count).save!
    end

    self.send(self.class.dalliance_options[:dalliance_method])

    finish_dalliance!
  rescue StandardError => e
    #Save the error for future analysis...
    self.dalliance_error_hash = {:error => e.class.name, :message => e.message, :backtrace => e.backtrace}

    error_dalliance!

    #Don't raise the error if we're backgound_processing...
    raise e unless backgound_processing
  ensure
    if self.class.dalliance_options[:dalliance_progress_meter] && dalliance_progress_meter
      #Works with optimistic locking...
      Dalliance::ProgressMeter.delete(dalliance_progress_meter.id)
      self.dalliance_progress_meter = nil
    end

    duration = Time.now - start_time

    if self.class.dalliance_options[:logger]
      self.class.dalliance_options[:logger].info("[dalliance] #{self.class.name}(#{id}) - #{dalliance_status} #{duration.to_i}")
    end

    if self.class.dalliance_options[:duration_column]
      self.class.where(id: self.id).update_all(self.class.dalliance_options[:duration_column] => duration.to_i)
    end
  end
end

#dalliance_progress ⇒ Object 



177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/dalliance.rb', line 177

def dalliance_progress
  if completed?
    100
  else
    if self.class.dalliance_options[:dalliance_progress_meter] && dalliance_progress_meter
      dalliance_progress_meter.progress
    else
      0
    end
  end
end

#error_or_completed? ⇒ Boolean

Returns:

  • (Boolean) 


119
120
121
 
# File 'lib/dalliance.rb', line 119

def error_or_completed?
  processing_error? || completed?
end

#pending_or_processing? ⇒ Boolean

Returns:

  • (Boolean) 


123
124
125
 
# File 'lib/dalliance.rb', line 123

def pending_or_processing?
  pending? || processing?
end