require "time"

# 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 channel of the
# same name.
requests = Channel(Int32).new(5)
5.times do |i|
  requests.send(i + 1)
end
requests.close

# This `limiter` channel will receive a value
# every 200 milliseconds. This is the regulator in
# our rate limiting scheme.
limiter = Channel(Time).new
spawn do
  loop do
    sleep 200.milliseconds
    limiter.send(Time.utc)
  end
end

# By blocking on a receive from the `limiter` channel
# before serving each request, we limit ourselves to
# 1 request every 200 milliseconds.
requests.each do |req|
  limiter.receive
  puts "request #{req} #{Time.utc}"
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
# buffering our limiter channel. This `bursty_limiter`
# channel will allow bursts of up to 3 events.
bursty_limiter = Channel(Time).new(3)

# Fill up the channel to represent allowed bursting.
3.times { bursty_limiter.send(Time.utc) }

# Every 200 milliseconds we'll try to add a new
# value to `bursty_limiter`, up to its limit of 3.
spawn do
  loop do
    sleep 200.milliseconds
    bursty_limiter.send(Time.utc)
  end
end

# Now simulate 5 more incoming requests. The first
# 3 of these will benefit from the burst capability
# of `bursty_limiter`.
bursty_requests = Channel(Int32).new(5)
5.times do |i|
  bursty_requests.send(i + 1)
end
bursty_requests.close

bursty_requests.each do |req|
  bursty_limiter.receive
  puts "request #{req} #{Time.utc}"
end