Class: Joblin::Batching::Batch::Callback::Finalize

Inherits:
Object
  • Object
show all
Defined in:
lib/joblin/batching/callback.rb

Instance Method Summary collapse

Instance Method Details

#complete(bid, status, parent_bid) ⇒ Object 



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/joblin/batching/callback.rb', line 93

def complete(bid, status, parent_bid)
  return unless parent_bid

  pending, children, success = Batch.redis do |r|
    r.multi do |r|
      r.hincrby("BID-#{bid}", "pending", 0)
      r.hincrby("BID-#{bid}", "children", 0)
      r.scard("BID-#{bid}-batches-success")
    end
  end

  if !(pending.to_i.zero? && children == success)
    # If batch was not successfull check and see if its parent is complete
    # if the parent is complete we can trigger its complete callback.
    #
    # Otherwise, we don't want to to trigger the parent's :complete here (and
    # we instead opt to have success tigger parent :complete) - this
    # allows the success callback to add additional jobs to the parent batch
    # before triggering :complete.

    Batch.with_callback_check(parent_bid, except: [:success]) do |r|
      r.sadd("BID-#{parent_bid}-batches-complete", bid)
      r.sadd("BID-#{parent_bid}-batches-failed", bid)
    end
  end
end

#death(bid, status, parent_bid) ⇒ Object 



120
121
122
123
124
125
126
 
# File 'lib/joblin/batching/callback.rb', line 120

def death(bid, status, parent_bid)
  return unless parent_bid

  # We only need to bubble the event here - other events (eg stagnation) will be checked and bubbled elsewhere.

  Batch.enqueue_callbacks(:death, parent_bid)
end

#dispatch(status, opts) ⇒ Object

The methods in this class are called after all same-named callbacks have been completed for the passed Batch. These methods mainly handle bubbling events up to the parent Batch You could say that they are the callbacks for callbacks.



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
 
# File 'lib/joblin/batching/callback.rb', line 48

def dispatch(status, opts)
  bid = opts["bid"]
  event = opts["event"].to_sym

  Batch.logger.debug {"Finalize #{event} batch id: #{opts["bid"]}"}

  batch_status = Status.new bid
  send(event, bid, batch_status, batch_status.parent_bid)

  Batch.redis do |r|
    r.srem("BID-#{bid}-pending_callbacks", "#{event}-finalize")
  end

  # This is a callback for a callback. In this case we need to check if we should cleanup the original bid.
  if event == :success || (CLEANUP_STAGNATED_BATCHES && event == :stagnated)
    if opts['origin'].present?
      origin_bid = opts['origin']['for_bid']
      _, pending, success_ran, stagnated_ran = Batch.redis do |r|
        r.multi do |r|
          r.srem("BID-#{origin_bid}-pending_callbacks", opts['origin']['event'])
          r.scard("BID-#{origin_bid}-pending_callbacks")
          r.hget("BID-#{origin_bid}", "success")
          r.hget("BID-#{origin_bid}", "stagnated")
        end
      end

      Batch.cleanup_redis(origin_bid) if pending == 0 && (success_ran == 'true' || (stagnated_ran == 'true' && CLEANUP_STAGNATED_BATCHES))
    end

    if (Batch.redis {|r| r.scard("BID-#{bid}-pending_callbacks") }) == 0
      Batch.cleanup_redis(bid)
    end
  end
end

#stagnated(bid, status, parent_bid) ⇒ Object 



128
129
130
131
132
133
134
135
 
# File 'lib/joblin/batching/callback.rb', line 128

def stagnated(bid, status, parent_bid)
  return unless parent_bid

  Batch.with_callback_check(parent_bid) do |r|
    r.sadd("BID-#{parent_bid}-batches-stagnated", bid)
    r.expire("BID-#{parent_bid}-batches-stagnated", BID_EXPIRE_TTL)
  end
end

#success(bid, status, parent_bid) ⇒ Object 



83
84
85
86
87
88
89
90
91
 
# File 'lib/joblin/batching/callback.rb', line 83

def success(bid, status, parent_bid)
  return unless parent_bid

  Batch.with_callback_check(parent_bid) do |r|
    r.sadd("BID-#{parent_bid}-batches-success", bid)
    r.srem("BID-#{parent_bid}-batches-failed", bid)
    r.sadd("BID-#{parent_bid}-batches-complete", bid)
  end
end