#lang racket

(require racket/async-channel)

(define (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 channel of the
  ; same name.
  (define requests (make-async-channel 5))
  (for ([i (in-range 1 6)])
    (async-channel-put requests i))
  (async-channel-put requests eof)

  ; This `limiter` thread will send a value
  ; every 200 milliseconds. This is the regulator in
  ; our rate limiting scheme.
  (define limiter (thread
                   (lambda ()
                     (let loop ()
                       (sleep 0.2)
                       (sync (thread-send-evt (current-thread) 'tick))
                       (loop)))))

  ; By blocking on a receive from the `limiter` thread
  ; before serving each request, we limit ourselves to
  ; 1 request every 200 milliseconds.
  (let loop ()
    (define req (async-channel-get requests))
    (when (not (eof-object? req))
      (thread-receive)
      (printf "request ~a ~a\n" req (current-seconds))
      (loop)))

  ; 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.
  (define bursty-limiter (make-async-channel 3))

  ; Fill up the channel to represent allowed bursting.
  (for ([_ (in-range 3)])
    (async-channel-put bursty-limiter (current-seconds)))

  ; Every 200 milliseconds we'll try to add a new
  ; value to `bursty-limiter`, up to its limit of 3.
  (thread
   (lambda ()
     (let loop ()
       (sleep 0.2)
       (async-channel-put bursty-limiter (current-seconds))
       (loop))))

  ; Now simulate 5 more incoming requests. The first
  ; 3 of these will benefit from the burst capability
  ; of `bursty-limiter`.
  (define bursty-requests (make-async-channel 5))
  (for ([i (in-range 1 6)])
    (async-channel-put bursty-requests i))
  (async-channel-put bursty-requests eof)

  (let loop ()
    (define req (async-channel-get bursty-requests))
    (when (not (eof-object? req))
      (async-channel-get bursty-limiter)
      (printf "request ~a ~a\n" req (current-seconds))
      (loop))))

(main)