Struct slack_morphism::prelude::SlackApiRateControlLimit

source ·

pub struct SlackApiRateControlLimit {
    pub value: usize,
    pub per: Duration,
}

Expand description

A rate limit definition

Fields§

§value: usize§per: Duration

Implementations§

source §

impl SlackApiRateControlLimit

source

pub fn new(value: usize, per: Duration) -> Self

source

pub fn to_rate_limit_in_ms(&self) -> u64

Examples found in repository ?

src/ratectl/limit.rs (line 28)

    pub fn to_rate_limit_capacity(&self) -> usize {
        self.per.as_millis() as usize / self.to_rate_limit_in_ms() as usize
    }

    pub fn to_throttling_counter(&self) -> ThrottlingCounter {
        ThrottlingCounter::new(self.to_rate_limit_capacity(), self.to_rate_limit_in_ms())
    }

source

pub fn to_rate_limit_capacity(&self) -> usize

Examples found in repository ?

src/ratectl/limit.rs (line 32)

31
32
33

    pub fn to_throttling_counter(&self) -> ThrottlingCounter {
        ThrottlingCounter::new(self.to_rate_limit_capacity(), self.to_rate_limit_in_ms())
    }

source

pub fn to_throttling_counter(&self) -> ThrottlingCounter

Examples found in repository ?

src/ratectl/team_limits.rs (line 19)

    pub fn new(rate_control_config: &SlackApiRateControlConfig) -> Self {
        Self {
            team_limit_counter: rate_control_config
                .team_max_rate_limit
                .clone()
                .map(|rl| rl.to_throttling_counter()),
            tier_limits: HashMap::new(),
            special_limits: HashMap::new(),
            updated: Instant::now(),
        }
    }

More examples

Hide additional examples

src/ratectl/throttler.rs (line 19)

    pub fn new(rate_control_config: SlackApiRateControlConfig) -> Self {
        let global_max_rate_limit_counter = rate_control_config
            .global_max_rate_limit
            .clone()
            .map(|rl| rl.to_throttling_counter());
        Self {
            config: rate_control_config,
            global_max_rate_limit_counter,
            global_all_team_special_limits: HashMap::new(),
            rate_limit_per_team: HashMap::new(),
        }
    }

    pub fn calc_throttle_delay(
        &mut self,
        method_rate_ctl: &SlackApiMethodRateControlConfig,
        team_id: Option<SlackTeamId>,
        min_delayed: Option<Duration>,
    ) -> Option<Duration> {
        let mut delays_heap: BinaryHeap<Duration> = BinaryHeap::new();
        let now = Instant::now();

        min_delayed
            .iter()
            .filter(|d| !d.is_zero())
            .for_each(|d| delays_heap.push(*d));

        self.global_max_rate_limit_counter
            .as_ref()
            .map(|c| c.update(now))
            .into_iter()
            .for_each(|updated_counter| {
                if !updated_counter.delay().is_zero() {
                    delays_heap.push(*updated_counter.delay())
                }
                self.global_max_rate_limit_counter = Some(updated_counter);
            });

        match team_id {
            Some(team_id) => {
                let team_limits = self
                    .rate_limit_per_team
                    .entry(team_id)
                    .or_insert_with(|| SlackTeamLimits::new(&self.config));
                team_limits.updated = now;

                team_limits
                    .team_limit_counter
                    .as_ref()
                    .map(|c| c.update(now))
                    .into_iter()
                    .for_each(|updated_counter| {
                        if !updated_counter.delay().is_zero() {
                            delays_heap.push(*updated_counter.delay())
                        }
                        team_limits.team_limit_counter = Some(updated_counter);
                    });

                if let Some(ref special_rate_limit) = method_rate_ctl.special_rate_limit {
                    let special_team_limit = team_limits
                        .special_limits
                        .entry(special_rate_limit.key.clone())
                        .or_insert_with(|| special_rate_limit.limit.to_throttling_counter());

                    *special_team_limit = special_team_limit.update(now);

                    if !special_team_limit.delay().is_zero() {
                        delays_heap.push(*special_team_limit.delay())
                    }
                }

                if let Some(ref tier) = method_rate_ctl.tier {
                    if let Some(tier_limit) = self.config.tiers_limits.get(tier) {
                        let tier_team_limit = team_limits
                            .tier_limits
                            .entry(tier.clone())
                            .or_insert_with(|| tier_limit.to_throttling_counter());

                        *tier_team_limit = tier_team_limit.update(now);

                        if !tier_team_limit.delay().is_zero() {
                            delays_heap.push(*tier_team_limit.delay())
                        }
                    }
                }

                // Clean up old teams limits
                self.rate_limit_per_team
                    .retain(|_, v| v.updated.duration_since(now).as_secs() < 3600);
            }
            None => {
                if let Some(ref special_method_limits) = method_rate_ctl.special_rate_limit {
                    let special_team_limit = self
                        .global_all_team_special_limits
                        .entry(special_method_limits.key.clone())
                        .or_insert_with(|| special_method_limits.limit.to_throttling_counter());

                    *special_team_limit = special_team_limit.update(now);

                    if !special_team_limit.delay().is_zero() {
                        delays_heap.push(*special_team_limit.delay())
                    }
                }
            }
        }

        delays_heap.pop()
    }