robotrt-middleware-core 0.1.0-beta.2

RobotRT modular robotics runtime and middleware components.
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

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

use core_types::TransportDomain;
use transport_core::Endpoint;

use super::{RouteHint, RouteTrafficKind};

fn endpoint_weight(endpoint: &Endpoint) -> u32 {
    for label in &endpoint.labels {
        if let Some(raw) = label
            .strip_prefix("weight=")
            .or_else(|| label.strip_prefix("weight:"))
            .or_else(|| label.strip_prefix("route-weight="))
            .or_else(|| label.strip_prefix("route-weight:"))
            .or_else(|| label.strip_prefix("w="))
            .or_else(|| label.strip_prefix("w:"))
            && let Ok(parsed) = raw.parse::<u32>()
        {
            return parsed.max(1);
        }
    }
    1
}

pub(super) fn weighted_pick<'a>(
    candidates: &'a [&Endpoint],
    hint: &RouteHint,
) -> Option<&'a Endpoint> {
    if candidates.is_empty() {
        return None;
    }
    if candidates.len() == 1 {
        return Some(candidates[0]);
    }

    let total: u64 = candidates
        .iter()
        .map(|endpoint| u64::from(endpoint_weight(endpoint)))
        .sum();
    if total == 0 {
        return Some(candidates[0]);
    }

    let mut slot = route_seed(hint) % total;
    for endpoint in candidates {
        let weight = u64::from(endpoint_weight(endpoint));
        if slot < weight {
            return Some(endpoint);
        }
        slot = slot.saturating_sub(weight);
    }
    candidates.last().copied()
}

fn route_seed(hint: &RouteHint) -> u64 {
    let mut hasher = DefaultHasher::new();
    match hint.preferred_domain {
        TransportDomain::Network => 0u8,
        TransportDomain::Local => 1u8,
    }
    .hash(&mut hasher);

    for label in &hint.labels {
        label.hash(&mut hasher);
    }

    if let Some(target_name) = &hint.target_name {
        target_name.hash(&mut hasher);
    }

    if let Some(kind) = hint.traffic_kind {
        match kind {
            RouteTrafficKind::Topic => 0u8,
            RouteTrafficKind::Service => 1u8,
            RouteTrafficKind::Action => 2u8,
            RouteTrafficKind::Mission => 3u8,
        }
        .hash(&mut hasher);
    }

    hasher.finish()
}