bouncer 1.0.1

Bouncer allows you handle your requests to third-party services with no worries, perhaps some worries.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use crate::settings::Settings;
use crate::stats::Stats;

use redis::{Client, RedisResult, Script};
use std::fs::read_to_string;
use std::thread;

#[derive(Clone)]
pub struct Bouncer<'a> {
    pub key: u8,
    pub rate_limit: u8,
    pub wait_time: u8,
    pub block: &'a dyn Fn(),
}

impl<'a> Default for Bouncer<'a> {
    /// Default values for a Bouncer instance.
    fn default() -> Bouncer<'a> {
        Bouncer {
            key: 1,
            rate_limit: 5,
            wait_time: 2,
            block: &|| println!("Nothing to execute"),
        }
    }
}

impl<'a> Bouncer<'a> {
    /// Returns a Bouncer instance
    ///
    /// # Arguments
    ///
    /// * `block` - A block or a function that will execute a request to a third-party service.
    pub fn new(block: &'a dyn Fn()) -> Bouncer {
        let mut bouncer = Bouncer::default();
        bouncer.block = block;
        bouncer
    }

    /// Assigns a key to the process to be executed.
    ///
    /// # Arguments
    ///
    /// * `key` - A integer to identify the process.
    pub fn key(&'a mut self, key: u8) -> &'a mut Bouncer {
        self.key = key;
        self
    }

    /// Assigns a rate limit to the process to be executed.
    ///
    /// # Arguments
    ///
    /// * `rate_limit` - limit the number of calls.
    pub fn rate_limit(&'a mut self, rate_limit: u8) -> &'a mut Bouncer {
        self.rate_limit = rate_limit;
        self
    }

    /// Assigns a waiting time to the process to be executed.
    ///
    /// # Arguments
    ///
    /// * `wait_time` - A value in seconds to wait until the next request to be executed.
    pub fn wait_time(&'a mut self, wait_time: u8) -> &'a mut Bouncer {
        self.wait_time = wait_time;
        self
    }

    /// Executes the passed block.
    pub fn run(&self) -> RedisResult<Stats> {
        match Settings::new() {
            Ok(settings) => {
                let raw_script = read_to_string(settings.redis_script())?;
                let script = Script::new(raw_script.as_str());
                let client = Client::open(settings.redis_url())?;
                let mut connection = client.get_connection()?;
                loop {
                    let stats: Stats = script
                        .key(self.key)
                        .arg(self.rate_limit)
                        .arg(self.wait_time)
                        .invoke(&mut connection)
                        .unwrap();
                    if stats == Stats::default() {
                        (self.block)();
                        break Ok(stats);
                    } else {
                        thread::sleep(stats.wait)
                    }
                }
            }
            Err(error) => panic!("{}", error),
        }
    }
}