Struct api_key_pool::APIKeyPool

pub struct APIKeyPool { /* private fields */ }

A pool of API keys.

Implementations

impl APIKeyPool

pub fn new() -> Self

Returns an empty API key pool.

Examples found in repository

examples/api-key-pool.rs (line 19)

async fn main() {
    // Create a RateLimitPolicy to be applied to all API keys.
    // Note: An APIPool can have APIKeys with different RateLimitPolicies.
    //       For the sake of simplicity, this example assumes identical policies.
    let pol = RateLimitPolicy::new(1, Duration::seconds(2));

    // Create the APIKeys.
    let api1 = APIKey::new("1", pol);
    let api2 = APIKey::new("2", pol);
    let api3 = APIKey::new("3", pol);

    // Create the APIKeyPool.
    let mut pool = APIKeyPool::new();
    pool.add_key(api1).await;
    pool.add_key(api2).await;
    pool.add_key(api3).await;

    // Simulate 20 requests.
    let mut ctr = 0;
    while ctr < 20 {
        // Use the APIKey if available (according to its respective RateLimitPolicy) or sleep.
        if let Some(key) = pool.poll_for_key().await {
            println!("{}", key);
            ctr += 1;
        } else {
            println!("Have to sleep.");
            time::sleep(time::Duration::from_millis(500)).await;
        }
    }
}

pub async fn add_key(&mut self, key: APIKey)

Adds an API key to an API key pool.

Arguments

• key - the API key to be added.

Examples found in repository

examples/api-key-pool.rs (line 20)

async fn main() {
    // Create a RateLimitPolicy to be applied to all API keys.
    // Note: An APIPool can have APIKeys with different RateLimitPolicies.
    //       For the sake of simplicity, this example assumes identical policies.
    let pol = RateLimitPolicy::new(1, Duration::seconds(2));

    // Create the APIKeys.
    let api1 = APIKey::new("1", pol);
    let api2 = APIKey::new("2", pol);
    let api3 = APIKey::new("3", pol);

    // Create the APIKeyPool.
    let mut pool = APIKeyPool::new();
    pool.add_key(api1).await;
    pool.add_key(api2).await;
    pool.add_key(api3).await;

    // Simulate 20 requests.
    let mut ctr = 0;
    while ctr < 20 {
        // Use the APIKey if available (according to its respective RateLimitPolicy) or sleep.
        if let Some(key) = pool.poll_for_key().await {
            println!("{}", key);
            ctr += 1;
        } else {
            println!("Have to sleep.");
            time::sleep(time::Duration::from_millis(500)).await;
        }
    }
}

pub async fn poll_for_key(&mut self) -> Option<String>

Checks the API key pool for any available API keys, and returns the API key if available.

Examples found in repository

examples/api-key-pool.rs (line 28)

async fn main() {
    // Create a RateLimitPolicy to be applied to all API keys.
    // Note: An APIPool can have APIKeys with different RateLimitPolicies.
    //       For the sake of simplicity, this example assumes identical policies.
    let pol = RateLimitPolicy::new(1, Duration::seconds(2));

    // Create the APIKeys.
    let api1 = APIKey::new("1", pol);
    let api2 = APIKey::new("2", pol);
    let api3 = APIKey::new("3", pol);

    // Create the APIKeyPool.
    let mut pool = APIKeyPool::new();
    pool.add_key(api1).await;
    pool.add_key(api2).await;
    pool.add_key(api3).await;

    // Simulate 20 requests.
    let mut ctr = 0;
    while ctr < 20 {
        // Use the APIKey if available (according to its respective RateLimitPolicy) or sleep.
        if let Some(key) = pool.poll_for_key().await {
            println!("{}", key);
            ctr += 1;
        } else {
            println!("Have to sleep.");
            time::sleep(time::Duration::from_millis(500)).await;
        }
    }
}

Trait Implementations

impl Default for APIKeyPool

fn default() -> APIKeyPool

Returns the “default value” for a type.