require 'thread'

def main
  # First we'll look at basic rate limiting. Suppose
  # we want to limit our handling of incoming requests.
  # We'll serve these requests off a queue of the same name.
  requests = Queue.new
  5.times { |i| requests.push(i + 1) }

  # This limiter will receive a value every 200 milliseconds.
  # This is the regulator in our rate limiting scheme.
  limiter = Queue.new
  Thread.new do
    loop do
      sleep(0.2)
      limiter.push(true)
    end
  end

  # By blocking on a receive from the limiter queue
  # before serving each request, we limit ourselves to
  # 1 request every 200 milliseconds.
  until requests.empty?
    limiter.pop
    req = requests.pop
    puts "request #{req} #{Time.now}"
  end

  # We may want to allow short bursts of requests in
  # our rate limiting scheme while preserving the
  # overall rate limit. We can accomplish this by
  # using a SizedQueue. This bursty_limiter
  # queue will allow bursts of up to 3 events.
  bursty_limiter = SizedQueue.new(3)

  # Fill up the queue to represent allowed bursting.
  3.times { bursty_limiter.push(Time.now) }

  # Every 200 milliseconds we'll try to add a new
  # value to bursty_limiter, up to its limit of 3.
  Thread.new do
    loop do
      sleep(0.2)
      bursty_limiter.push(Time.now) rescue nil
    end
  end

  # Now simulate 5 more incoming requests. The first
  # 3 of these will benefit from the burst capability
  # of bursty_limiter.
  bursty_requests = Queue.new
  5.times { |i| bursty_requests.push(i + 1) }

  until bursty_requests.empty?
    bursty_limiter.pop
    req = bursty_requests.pop
    puts "request #{req} #{Time.now}"
  end
end

main