import std.stdio;
import core.thread;
import std.datetime;

void 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.
    auto requests = new Channel!int(5);
    foreach (i; 1 .. 6)
    {
        requests.put(i);
    }
    requests.close();

    // This limiter timer will fire every 200 milliseconds.
    // This is the regulator in our rate limiting scheme.
    auto limiter = new Timer(200.msecs);

    // By waiting for the limiter timer before serving each request,
    // we limit ourselves to 1 request every 200 milliseconds.
    foreach (req; requests)
    {
        limiter.wait();
        writeln("request ", req, " ", Clock.currTime());
    }

    // 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 semaphore. This burstyLimiter
    // will allow bursts of up to 3 events.
    auto burstyLimiter = new Semaphore(3);

    // Fill up the semaphore to represent allowed bursting.
    foreach (i; 0 .. 3)
    {
        burstyLimiter.notify();
    }

    // Every 200 milliseconds we'll try to add a new
    // value to burstyLimiter, up to its limit of 3.
    new Thread({
        while (true)
        {
            Thread.sleep(200.msecs);
            burstyLimiter.notify();
        }
    }).start();

    // Now simulate 5 more incoming requests. The first
    // 3 of these will benefit from the burst capability
    // of burstyLimiter.
    auto burstyRequests = new Channel!int(5);
    foreach (i; 1 .. 6)
    {
        burstyRequests.put(i);
    }
    burstyRequests.close();

    foreach (req; burstyRequests)
    {
        burstyLimiter.wait();
        writeln("request ", req, " ", Clock.currTime());
    }
}