Class: CanvasSync::JobBatches::Batch::Callback::Finalize

Inherits:
Object
  • Object
show all
Defined in:
lib/canvas_sync/job_batches/callback.rb

Instance Method Summary collapse

Instance Method Details

#complete(bid, status, parent_bid) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/canvas_sync/job_batches/callback.rb', line 89

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 



116
117
118
119
120
121
122
 
# File 'lib/canvas_sync/job_batches/callback.rb', line 116

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.



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
 
# File 'lib/canvas_sync/job_batches/callback.rb', line 46

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

  if event == :success
    if opts['origin'].present?
      # This is a callback for a callback. In this case we need to check if we should cleanup the original bid.
      origin_bid = opts['origin']['for_bid']
      _, pending, success_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")
        end
      end
      Batch.cleanup_redis(origin_bid) if pending == 0 && success_ran == 'true'
    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 



124
125
126
127
128
129
130
131
 
# File 'lib/canvas_sync/job_batches/callback.rb', line 124

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 



79
80
81
82
83
84
85
86
87
 
# File 'lib/canvas_sync/job_batches/callback.rb', line 79

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