Class: Kungfuig::Jobber

Inherits:
Object
  • Object
show all
Defined in:
lib/kungfuig/jobber.rb

Overview

Generic helper for massive attaching aspects

Defined Under Namespace

Classes: Dummy, DummyExecutor

Constant Summary collapse

RESPOND_TO = 
->(m, r) { r.respond_to? m.to_sym }

Class Method Summary collapse

Class Method Details

.bottleneck(method: nil, receiver: nil, result: nil, **params) ⇒ Object 



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/kungfuig/jobber.rb', line 77

def bottleneck(method: nil, receiver: nil, result: nil, **params)
  return unless (receiver_class = receiver.class.ancestors.detect do |c|
    @hash[c.name] && @hash[c.name][method]
  end)

  receiver, worker = patch_receiver(receiver, receiver_class.name, method)
  worker_params = { receiver: receiver, method: method, result: result, **params }
  if (delay = delay(receiver_class.name, method))
    Dummy.perform_async(
      digest: digest(receiver, receiver_class.name, method),
      delay: delay,
      worker: worker.to_s,
      worker_params: worker_params
    )
  else
    worker.perform_async(worker_params)
  end
rescue => e
  Kungfuig.✍(receiver: [
    "Fail [#{e.message}]",
    *e.backtrace.unshift("Backtrace:").join("#{$/}⮩  "),
    "while #{receiver}"
  ].join($/), method: method, result: result, args: params)
end

.bulk(hos) ⇒ Object

‘Test’:

'*': 'YoJob'



68
69
70
71
72
73
74
75
 
# File 'lib/kungfuig/jobber.rb', line 68

def bulk(hos)
  @hash = Kungfuig.load_stuff hos
  Kungfuig::Aspector.bulk(
    @hash.map do |klazz, hash|
      [klazz, { after: hash.map { |k, _| [k, 'Kungfuig::Jobber#bottleneck'] }.to_h }]
    end.to_h
  )
end

.delay(target, name) ⇒ Object 



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

def delay target, name
  @hash[target][name].is_a?(Hash) && @hash[target][name]['delay'].to_i || nil
end

.digest(result, target, name) ⇒ Object 



127
128
129
130
131
132
 
# File 'lib/kungfuig/jobber.rb', line 127

def digest result, target, name
  fields = @hash[target][name].is_a?(Hash) && @hash[target][name]['compare_by']
  Digest::SHA256.hexdigest(
    (fields.nil? ? result : fields.map { |f| result[f] }).inspect
  )
end

.patch_receiver(receiver, target, name) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/kungfuig/jobber.rb', line 104

def patch_receiver(receiver, target, name)
  r =     case receiver
          when Hash, Array, String then receiver
          when RESPOND_TO.curry[:to_hash] then receiver.to_hash
          when RESPOND_TO.curry[:to_h] then receiver.to_h
          else receiver
          end

  klazz = case @hash[target][name]
          when String, Symbol then @hash[target][name]
          when Hash then @hash[target][name]['class']
          else return
          end

  [r, Kernel.const_get(klazz).tap do |c|
    c.send(:prepend, Kungfuig::Worker) unless c.ancestors.include? Kungfuig::Worker
  end]
end