Struct qiniu_http_client::ChooseOptions

pub struct ChooseOptions<'a> { /* private fields */ }

选择 IP 地址列表的选项

Implementations

impl<'a> ChooseOptions<'a>

pub fn domain(&'a self) -> Option<&'a DomainWithPort>

获取 IP 地址的域名

Examples found in repository

src/client/chooser/ip.rs (line 88)

    fn choose(&self, ips: &[IpAddrWithPort], opts: ChooseOptions) -> ChosenResults {
        let mut need_to_shrink = false;
        let filtered_ips: Vec<_> = ips
            .iter()
            .copied()
            .filter(|&ip| {
                self.inner
                    .blacklist
                    .get(&BlacklistKey {
                        ip,
                        domain: opts.domain().cloned(),
                    })
                    .map_or(true, |r| {
                        if r.value().blocked_at.elapsed() < self.inner.block_duration {
                            false
                        } else {
                            need_to_shrink = true;
                            true
                        }
                    })
            })
            .collect();
        do_some_work_async(&self.inner, need_to_shrink);
        filtered_ips.into()
    }

src/client/chooser/subnet.rs (line 98)

    fn choose(&self, ips: &[IpAddrWithPort], opts: ChooseOptions) -> ChosenResults {
        let mut need_to_shrink = false;
        let mut subnets_map: HashMap<Subnet, Vec<IpAddrWithPort>> = Default::default();
        for &ip in ips.iter() {
            let is_blocked = self
                .inner
                .blacklist
                .get(&BlacklistKey {
                    ip,
                    domain: opts.domain().cloned(),
                })
                .map_or(false, |r| {
                    if r.value().blocked_at.elapsed() < self.inner.block_duration {
                        true
                    } else {
                        need_to_shrink = true;
                        false
                    }
                });
            if !is_blocked {
                let subnet = self.get_network_address(ip);
                if let Some(ips) = subnets_map.get_mut(&subnet) {
                    ips.push(ip);
                } else {
                    subnets_map.insert(subnet, vec![ip]);
                }
            }
        }
        let chosen_ips = choose_group(subnets_map.into_values()).unwrap_or_default();
        do_some_work_async(&self.inner, need_to_shrink);
        return chosen_ips.into();

        /// For production, choose any subnet by random
        #[cfg(not(test))]
        fn choose_group(iter: impl Iterator<Item = Vec<IpAddrWithPort>>) -> Option<Vec<IpAddrWithPort>> {
            use rand::prelude::IteratorRandom;

            iter.choose(&mut rand::thread_rng())
        }

        /// For Test cases, always choose the biggest subnet
        #[cfg(test)]
        fn choose_group(iter: impl Iterator<Item = Vec<IpAddrWithPort>>) -> Option<Vec<IpAddrWithPort>> {
            iter.max_by_key(|ips| ips.len())
        }
    }

pub fn builder() -> ChooseOptionsBuilder<'a>

创建选择 IP 地址列表的选项构建器

Trait Implementations

impl<'a> Clone for ChooseOptions<'a>

fn clone(&self) -> ChooseOptions<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ChooseOptions<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Default for ChooseOptions<'a>

fn default() -> ChooseOptions<'a>

Returns the “default value” for a type.

impl<'a> Copy for ChooseOptions<'a>