1mod candidate;
5
6use crate::filter::GuardFilter;
7use crate::guard::{Guard, NewlyConfirmed, Reachable};
8use crate::skew::SkewObservation;
9use crate::{
10 ExternalActivity, GuardParams, GuardUsage, GuardUsageKind, PickGuardError, ids::GuardId,
11};
12use crate::{FirstHop, GuardSetSelector};
13use saturating_time::SaturatingTime as _;
14use tor_basic_utils::iter::{FilterCount, IteratorExt as _};
15use tor_basic_utils::onionperf_types::{OnionperfEvent, OnionperfGuardStatus};
16use tor_error::{internal, warn_report};
17use tor_linkspec::{ByRelayIds, HasRelayIds};
18
19use itertools::Itertools;
20use rand::seq::IndexedRandom;
21use serde::{Deserialize, Serialize};
22use std::borrow::Cow;
23use std::collections::{HashMap, HashSet};
24use tracing::{debug, info, trace};
25use web_time_compat::{Instant, SystemTime};
26
27#[allow(unused_imports)]
28pub(crate) use candidate::{Candidate, CandidateStatus, Universe, UniverseRef, WeightThreshold};
29
30#[derive(Debug, Default, Clone, Deserialize)]
51#[serde(from = "GuardSample")]
52pub(crate) struct GuardSet {
53 guards: ByRelayIds<Guard>,
113 sample: Vec<GuardId>,
117 confirmed: Vec<GuardId>,
122 primary: Vec<GuardId>,
127 active_filter: GuardFilter,
134
135 filter_is_restrictive: bool,
137
138 primary_guards_invalidated: bool,
141
142 unknown_fields: HashMap<String, JsonValue>,
145}
146
147#[derive(Debug, Copy, Clone, Eq, PartialEq)]
149pub(crate) enum ListKind {
150 Primary,
152 Confirmed,
154 Sample,
156 Fallback,
158}
159
160impl ListKind {
161 pub(crate) fn is_primary(&self) -> bool {
163 self == &ListKind::Primary
164 }
165
166 pub(crate) fn usable_immediately(&self) -> bool {
170 match self {
171 ListKind::Primary | ListKind::Fallback => true,
172 ListKind::Confirmed | ListKind::Sample => false,
173 }
174 }
175}
176
177impl GuardSet {
178 fn inner_lengths(&self) -> (usize, usize, usize, usize) {
182 (
183 self.guards.len(),
184 self.sample.len(),
185 self.confirmed.len(),
186 self.primary.len(),
187 )
188 }
189
190 fn fix_consistency(&mut self) {
197 fn fix_id_list(guards: &ByRelayIds<Guard>, id_list: &mut Vec<GuardId>) {
201 id_list.retain_mut(|id| match guards.by_all_ids(id) {
202 Some(guard) => {
203 *id = guard.guard_id().clone();
204 true
205 }
206 None => false,
207 });
208 }
209
210 let sample_set: HashSet<_> = self.sample.iter().collect();
211 self.guards.retain(|g| sample_set.contains(g.guard_id()));
212 fix_id_list(&self.guards, &mut self.sample);
213 fix_id_list(&self.guards, &mut self.confirmed);
214 fix_id_list(&self.guards, &mut self.primary);
215 }
216
217 fn assert_consistency(&mut self) {
223 let len_pre = self.inner_lengths();
224 self.fix_consistency();
225 let len_post = self.inner_lengths();
226 if len_pre != len_post {
227 let e = internal!("Inner length changed from {len_pre:?} to {len_post:?}");
230 warn_report!(
231 e,
232 "Found guard sample in an inconsistent state, and restored it"
233 );
234 debug_assert_eq!(len_pre, len_post);
235 }
236 }
237
238 pub(crate) fn get(&self, id: &GuardId) -> Option<&Guard> {
240 self.guards.by_all_ids(id)
241 }
242
243 pub(crate) fn set_filter(&mut self, filter: GuardFilter, restrictive: bool) {
249 self.active_filter = filter;
250 self.filter_is_restrictive = restrictive;
251
252 self.assert_consistency();
253
254 let guards = &self.guards; let filt = &self.active_filter;
256 self.primary.retain(|id| {
257 guards
258 .by_all_ids(id)
259 .map(|g| g.usable() && filt.permits(g))
260 .unwrap_or(false)
261 });
262
263 self.primary_guards_invalidated = true;
264 }
265
266 pub(crate) fn filter(&self) -> &GuardFilter {
268 &self.active_filter
269 }
270
271 pub(crate) fn copy_ephemeral_status_into_newly_loaded_state(&mut self, mut other: GuardSet) {
279 let old_guards = std::mem::take(&mut self.guards);
280 self.guards = old_guards
281 .into_values()
282 .map(|guard| {
283 let id = guard.guard_id();
284
285 if let Some(other_guard) = other.guards.remove_exact(id) {
286 guard.copy_ephemeral_status_into_newly_loaded_state(other_guard)
287 } else {
288 guard
289 }
290 })
291 .collect();
292 }
293
294 fn get_state(&self) -> GuardSample<'_> {
297 let guards = self
298 .sample
299 .iter()
300 .map(|id| Cow::Borrowed(self.guards.by_all_ids(id).expect("Inconsistent state")))
301 .collect();
302
303 GuardSample {
304 guards,
305 confirmed: Cow::Borrowed(&self.confirmed),
306 remaining: self.unknown_fields.clone(),
307 }
308 }
309
310 fn from_state(state: GuardSample<'_>) -> Self {
312 let mut guards = ByRelayIds::new();
313 let mut sample = Vec::new();
314 for guard in state.guards {
315 sample.push(guard.guard_id().clone());
316 guards.insert(guard.into_owned());
317 }
318 let confirmed = state.confirmed.into_owned();
319 let primary = Vec::new();
320 let mut guard_set = GuardSet {
321 guards,
322 sample,
323 confirmed,
324 primary,
325 active_filter: GuardFilter::default(),
326 filter_is_restrictive: false,
327 primary_guards_invalidated: true,
328 unknown_fields: state.remaining,
329 };
330
331 let len_pre = guard_set.inner_lengths();
333 guard_set.fix_consistency();
334 let len_post = guard_set.inner_lengths();
335 if len_pre != len_post {
336 info!(
337 "Resolved a consistency issue in stored guard state. Diagnostic codes: {:?}, {:?}",
338 len_pre, len_post
339 );
340 }
341 debug!(
342 n_guards = len_post.0,
343 n_confirmed = len_post.2,
344 "Guard set loaded."
345 );
346
347 guard_set
348 }
349
350 pub(crate) fn contains(&self, id: &GuardId) -> Result<bool, &GuardId> {
357 let overlapping = self.guards.all_overlapping(id);
358 match &overlapping[..] {
359 [singleton] => {
360 if singleton.has_all_relay_ids_from(id) {
361 Ok(true)
362 } else {
363 Err(singleton.guard_id())
364 }
365 }
366 _ => Ok(false),
367 }
368 }
369
370 pub(crate) fn extend_sample_as_needed<U: Universe>(
380 &mut self,
381 now: SystemTime,
382 params: &GuardParams,
383 dir: &U,
384 ) -> crate::ExtendedStatus {
385 let mut any_added = crate::ExtendedStatus::No;
386 while self.extend_sample_inner(now, params, dir) {
387 any_added = crate::ExtendedStatus::Yes;
388 }
389 any_added
390 }
391
392 fn extend_sample_inner<U: Universe>(
402 &mut self,
403 now: SystemTime,
404 params: &GuardParams,
405 dir: &U,
406 ) -> bool {
407 self.assert_consistency();
408 let n_filtered_usable = self
409 .guards
410 .values()
411 .filter(|g| {
412 g.usable()
413 && self.active_filter.permits(*g)
414 && g.reachable() != Reachable::Unreachable
415 })
416 .count();
417 if n_filtered_usable >= params.min_filtered_sample_size {
418 return false; }
420 if self.guards.len() >= params.max_sample_size {
421 return false; }
423
424 let max_to_add = params.max_sample_size - self.sample.len();
426 let want_to_add = params.min_filtered_sample_size - n_filtered_usable;
427 let n_to_add = std::cmp::min(max_to_add, want_to_add);
428
429 let WeightThreshold {
430 mut current_weight,
431 maximum_weight,
432 } = dir.weight_threshold(&self.guards, params);
433
434 let no_filter = GuardFilter::unfiltered();
436 let (n_candidates, pre_filter) =
437 if self.filter_is_restrictive || self.active_filter.is_unfiltered() {
438 (n_to_add, &self.active_filter)
439 } else {
440 (n_to_add * 3, &no_filter)
443 };
444
445 let candidates = dir.sample(&self.guards, pre_filter, n_candidates);
446
447 let mut any_added = false;
449 let mut n_filtered_usable = n_filtered_usable;
450 for (candidate, weight) in candidates {
451 if current_weight >= maximum_weight
454 && self.guards.len() >= params.min_filtered_sample_size
455 {
456 break;
457 }
458 if self.guards.len() >= params.max_sample_size {
459 break;
461 }
462 if n_filtered_usable >= params.min_filtered_sample_size {
463 break;
465 }
466 if self.active_filter.permits(&candidate.owned_target) {
467 n_filtered_usable += 1;
468 }
469 current_weight += weight;
470 self.add_guard(candidate, now, params);
471 any_added = true;
472 }
473 self.assert_consistency();
474 any_added
475 }
476
477 fn add_guard(&mut self, relay: Candidate, now: SystemTime, params: &GuardParams) {
482 let id = GuardId::from_relay_ids(&relay.owned_target);
483 if self.guards.contains_any_overlapping(&id) {
484 return;
485 }
486 debug!(guard_id=?id, "Adding guard to sample.");
487 trace!(
490 onionperf = true,
491 event = ?OnionperfEvent::Guard(OnionperfGuardStatus::New),
492 guard_id = ?id,
493 );
494 let guard = Guard::from_candidate(relay, now, params);
495 self.guards.insert(guard);
496 self.sample.push(id);
497 self.primary_guards_invalidated = true;
498 }
499
500 pub(crate) fn n_primary_without_id_info_in<U: Universe>(&mut self, universe: &U) -> usize {
508 self.primary
509 .iter()
510 .filter(|id| {
511 let g = self
512 .guards
513 .by_all_ids(*id)
514 .expect("Inconsistent guard state");
515 g.listed_in(universe).is_none()
516 })
517 .count()
518 }
519
520 pub(crate) fn update_status_from_dir<U: Universe>(&mut self, dir: &U) {
522 let old_guards = std::mem::take(&mut self.guards);
523 self.guards = old_guards
524 .into_values()
525 .map(|mut guard| {
526 guard.update_from_universe(dir);
527 guard
528 })
529 .collect();
530 self.fix_consistency();
532 }
533
534 pub(crate) fn select_primary_guards(&mut self, params: &GuardParams) {
543 let old_primary = self.primary.clone();
550
551 self.primary = self
552 .confirmed
554 .iter()
555 .chain(self.primary.iter())
557 .chain(self.reachable_sample_ids())
560 .unique()
562 .filter_map(|id| {
564 let g = self
565 .guards
566 .by_all_ids(id)
567 .expect("Inconsistent guard state");
568 if g.usable() && self.active_filter.permits(g) {
569 Some(id.clone())
570 } else {
571 None
572 }
573 })
574 .take(params.n_primary)
576 .collect();
577
578 if self.primary != old_primary {
579 debug!(old=?old_primary, new=?self.primary, "Updated primary guards.");
580 }
581
582 for id in &self.primary {
584 self.guards.modify_by_all_ids(id, |guard| {
585 guard.note_exploratory_circ(false);
586 });
587 }
588
589 self.assert_consistency();
593 self.primary_guards_invalidated = false;
594 }
595
596 pub(crate) fn expire_old_guards(&mut self, params: &GuardParams, now: SystemTime) {
599 self.assert_consistency();
600 let n_pre = self.guards.len();
601 for guard in self.guards.values() {
603 if guard.is_expired(params, now) {
604 tracing::trace!(
605 onionperf = true,
606 event = ?OnionperfEvent::Guard(OnionperfGuardStatus::Dropped),
607 guard_id = ?guard.guard_id(),
608 );
609 }
610 }
611 self.guards.retain(|g| !g.is_expired(params, now));
612 let guards = &self.guards;
613 self.sample.retain(|id| guards.by_all_ids(id).is_some());
614 self.confirmed.retain(|id| guards.by_all_ids(id).is_some());
615 self.primary.retain(|id| guards.by_all_ids(id).is_some());
616 self.assert_consistency();
617
618 if self.guards.len() < n_pre {
619 let n_expired = n_pre - self.guards.len();
620 debug!(n_expired, "Expired guards as too old.");
621 self.primary_guards_invalidated = true;
622 }
623 }
624
625 fn reachable_sample_ids(&self) -> impl Iterator<Item = &GuardId> {
628 self.sample.iter().filter(move |id| {
629 let g = self
630 .guards
631 .by_all_ids(*id)
632 .expect("Inconsistent guard state");
633 g.reachable() != Reachable::Unreachable
634 })
635 }
636
637 fn preference_order_ids(&self) -> impl Iterator<Item = (ListKind, &GuardId)> {
647 self.primary
648 .iter()
649 .map(|id| (ListKind::Primary, id))
650 .chain(self.confirmed.iter().map(|id| (ListKind::Confirmed, id)))
651 .chain(self.sample.iter().map(|id| (ListKind::Sample, id)))
652 .unique_by(|(_, id)| *id)
653 }
654
655 fn preference_order(&self) -> impl Iterator<Item = (ListKind, &Guard)> + '_ {
657 self.preference_order_ids()
658 .filter_map(move |(p, id)| self.guards.by_all_ids(id).map(|g| (p, g)))
659 }
660
661 fn guard_is_primary(&self, guard_id: &GuardId) -> bool {
663 self.primary
667 .iter()
668 .any(|p| p.has_all_relay_ids_from(guard_id))
669 }
670
671 pub(crate) fn consider_all_retries(&mut self, now: Instant) {
674 let old_guards = std::mem::take(&mut self.guards);
675 self.guards = old_guards
676 .into_values()
677 .map(|mut guard| {
678 guard.consider_retry(now);
679 guard
680 })
681 .collect();
682 }
683
684 pub(crate) fn next_retry(&self, usage: &GuardUsage) -> Option<Instant> {
686 self.guards
687 .values()
688 .filter_map(|g| g.next_retry(usage))
689 .min()
690 }
691
692 pub(crate) fn mark_primary_guards_retriable(&mut self) {
694 for id in &self.primary {
695 self.guards
696 .modify_by_all_ids(id, |guard| guard.mark_retriable());
697 }
698 }
699
700 pub(crate) fn all_primary_guards_are_unreachable(&mut self) -> bool {
703 self.primary
704 .iter()
705 .flat_map(|id| self.guards.by_all_ids(id))
706 .all(|g| g.reachable() == Reachable::Unreachable)
707 }
708
709 pub(crate) fn mark_all_guards_retriable(&mut self) {
711 let old_guards = std::mem::take(&mut self.guards);
712 self.guards = old_guards
713 .into_values()
714 .map(|mut guard| {
715 guard.mark_retriable();
716 guard
717 })
718 .collect();
719 }
720
721 pub(crate) fn record_attempt(&mut self, guard_id: &GuardId, now: Instant) {
724 let is_primary = self.guard_is_primary(guard_id);
725 self.guards.modify_by_all_ids(guard_id, |guard| {
726 guard.record_attempt(now);
727
728 if !is_primary {
729 guard.note_exploratory_circ(true);
730 }
731 });
732 }
733
734 pub(crate) fn record_success(
740 &mut self,
741 guard_id: &GuardId,
742 params: &GuardParams,
743 how: Option<ExternalActivity>,
744 now: SystemTime,
745 ) {
746 self.assert_consistency();
747 self.guards.modify_by_all_ids(guard_id, |guard| match how {
748 Some(external) => guard.record_external_success(external),
749 None => {
750 let newly_confirmed = guard.record_success(now, params);
751
752 if newly_confirmed == NewlyConfirmed::Yes {
753 self.confirmed.push(guard_id.clone());
754 self.primary_guards_invalidated = true;
755 }
756 }
757 });
758 self.assert_consistency();
759 }
760
761 pub(crate) fn record_failure(
764 &mut self,
765 guard_id: &GuardId,
766 how: Option<ExternalActivity>,
767 now: Instant,
768 ) {
769 trace!(
770 onionperf = true,
771 event = ?OnionperfEvent::Guard(OnionperfGuardStatus::Down),
772 ?guard_id,
773 );
774 let is_primary = self.guard_is_primary(guard_id);
776 self.guards.modify_by_all_ids(guard_id, |guard| match how {
777 Some(external) => guard.record_external_failure(external, now),
778 None => guard.record_failure(now, is_primary),
779 });
780 }
781
782 pub(crate) fn record_attempt_abandoned(&mut self, guard_id: &GuardId) {
785 self.guards
786 .modify_by_all_ids(guard_id, |guard| guard.note_exploratory_circ(false));
787 }
788
789 pub(crate) fn record_indeterminate_result(&mut self, guard_id: &GuardId) {
793 self.guards.modify_by_all_ids(guard_id, |guard| {
794 guard.note_exploratory_circ(false);
795 guard.record_indeterminate_result();
796 });
797 }
798
799 pub(crate) fn record_skew(&mut self, guard_id: &GuardId, observation: SkewObservation) {
801 self.guards
802 .modify_by_all_ids(guard_id, |guard| guard.note_skew(observation));
803 }
804
805 pub(crate) fn skew_observations(&self) -> impl Iterator<Item = &SkewObservation> {
807 self.guards.values().filter_map(|g| g.skew())
808 }
809
810 pub(crate) fn circ_usability_status(
816 &self,
817 guard_id: &GuardId,
818 usage: &GuardUsage,
819 params: &GuardParams,
820 now: Instant,
821 ) -> Option<bool> {
822 if self.guard_is_primary(guard_id) {
839 return Some(true);
844 }
845
846 let cutoff = now.saturating_sub(params.np_connect_timeout);
854
855 for (src, guard) in self.preference_order() {
856 if guard.guard_id() == guard_id {
857 return Some(true);
858 }
859 if guard.usable() && self.active_filter.permits(guard) && guard.conforms_to_usage(usage)
860 {
861 match (src, guard.reachable()) {
862 (_, Reachable::Reachable) => return Some(false),
863 (_, Reachable::Unreachable) => (),
864 (ListKind::Primary, Reachable::Untried | Reachable::Retriable) => {
865 return Some(false);
866 }
867 (_, Reachable::Untried | Reachable::Retriable) => {
868 if guard.exploratory_attempt_after(cutoff) {
869 return None;
870 }
871 }
872 }
873 }
874 }
875
876 Some(false)
878 }
879
880 pub(crate) fn pick_guard(
891 &self,
892 sample_id: &GuardSetSelector,
893 usage: &GuardUsage,
894 params: &GuardParams,
895 now: Instant,
896 ) -> Result<(ListKind, FirstHop), PickGuardError> {
897 let (list_kind, id) = self.pick_guard_id(usage, params, now)?;
898 let first_hop = self
899 .get(&id)
900 .expect("Somehow selected a guard we don't know!")
901 .get_external_rep(sample_id.clone());
902 let first_hop = self.active_filter.modify_hop(first_hop)?;
903
904 Ok((list_kind, first_hop))
905 }
906
907 fn pick_guard_id(
911 &self,
912 usage: &GuardUsage,
913 params: &GuardParams,
914 now: Instant,
915 ) -> Result<(ListKind, GuardId), PickGuardError> {
916 debug_assert!(!self.primary_guards_invalidated);
917 let n_options = match usage.kind {
918 GuardUsageKind::OneHopDirectory => params.dir_parallelism,
919 GuardUsageKind::Data => params.data_parallelism,
920 };
921
922 let mut running = FilterCount::default();
929 let mut pending = FilterCount::default();
930 let mut suitable = FilterCount::default();
931 let mut filtered = FilterCount::default();
932
933 let mut options: Vec<_> = self
934 .preference_order()
935 .filter_cnt(&mut running, |(_, g)| {
938 g.usable()
939 && g.reachable() != Reachable::Unreachable
940 && g.ready_for_usage(usage, now)
941 })
942 .filter_cnt(&mut pending, |(_, g)| !g.exploratory_circ_pending())
945 .filter_cnt(&mut suitable, |(_, g)| g.conforms_to_usage(usage))
948 .filter_cnt(&mut filtered, |(_, g)| self.active_filter.permits(*g))
950 .take(n_options)
952 .collect();
953
954 if options.iter().any(|(src, _)| src.is_primary()) {
955 options.retain(|(src, _)| src.is_primary());
957 } else {
958 options.truncate(1);
960 }
961
962 match options.choose(&mut rand::rng()) {
963 Some((src, g)) => Ok((*src, g.guard_id().clone())),
964 None => {
965 let retry_at = if running.n_accepted == 0 {
966 self.next_retry(usage)
967 } else {
968 None
969 };
970 Err(PickGuardError::AllGuardsDown {
971 retry_at,
972 running,
973 pending,
974 suitable,
975 filtered,
976 })
977 }
978 }
979 }
980
981 #[cfg(feature = "bridge-client")]
987 pub(crate) fn descriptors_to_request(&self, now: Instant, params: &GuardParams) -> Vec<&Guard> {
988 const MINIMUM: usize = 2;
992
993 let maximum = std::cmp::max(params.data_parallelism, MINIMUM);
994 let data_usage = GuardUsage::default();
995
996 self.preference_order()
1006 .filter(|(_, g)| {
1007 g.usable()
1008 && g.reachable() != Reachable::Unreachable
1009 && g.ready_for_usage(&data_usage, now)
1010 && self.active_filter.permits(*g)
1011 })
1012 .take(maximum)
1013 .map(|(_, g)| g)
1014 .collect()
1015 }
1016}
1017
1018use serde::Serializer;
1019use tor_persist::JsonValue;
1020
1021#[derive(Default, Debug, Clone, Serialize, Deserialize)]
1023pub(crate) struct GuardSample<'a> {
1024 guards: Vec<Cow<'a, Guard>>,
1026 confirmed: Cow<'a, [GuardId]>,
1028 #[serde(flatten)]
1030 remaining: HashMap<String, JsonValue>,
1031}
1032
1033impl Serialize for GuardSet {
1034 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1035 where
1036 S: Serializer,
1037 {
1038 GuardSample::from(self).serialize(serializer)
1039 }
1040}
1041
1042impl<'a> From<&'a GuardSet> for GuardSample<'a> {
1043 fn from(guards: &'a GuardSet) -> Self {
1044 guards.get_state()
1045 }
1046}
1047
1048impl<'a> From<GuardSample<'a>> for GuardSet {
1049 fn from(sample: GuardSample) -> Self {
1050 GuardSet::from_state(sample)
1051 }
1052}
1053
1054#[cfg(test)]
1055mod test {
1056 #![allow(clippy::bool_assert_comparison)]
1058 #![allow(clippy::clone_on_copy)]
1059 #![allow(clippy::dbg_macro)]
1060 #![allow(clippy::mixed_attributes_style)]
1061 #![allow(clippy::print_stderr)]
1062 #![allow(clippy::print_stdout)]
1063 #![allow(clippy::single_char_pattern)]
1064 #![allow(clippy::unwrap_used)]
1065 #![allow(clippy::unchecked_time_subtraction)]
1066 #![allow(clippy::useless_vec)]
1067 #![allow(clippy::needless_pass_by_value)]
1068 #![allow(clippy::string_slice)] use tor_linkspec::{HasRelayIds, RelayIdType};
1071 use tor_netdir::NetDir;
1072 use tor_netdoc::doc::netstatus::RelayBandwidth;
1073 use tor_netdoc::types::relay_flags::RelayFlag;
1074 use web_time_compat::{InstantExt, SystemTimeExt};
1075
1076 use super::*;
1077 use crate::FirstHopId;
1078 use std::time::Duration;
1079
1080 fn netdir() -> NetDir {
1081 use tor_netdir::testnet;
1082 testnet::construct_netdir().unwrap_if_sufficient().unwrap()
1083 }
1084
1085 #[test]
1086 fn sample_test() {
1087 let netdir = tor_netdir::testnet::construct_custom_netdir(|idx, builder, _| {
1092 builder.rs.weight(RelayBandwidth::Measured(1000));
1094 if idx >= 10 {
1097 builder.rs.add_flags(RelayFlag::Guard);
1098 if idx >= 20 {
1099 builder.rs.protos("DirCache=2".parse().unwrap());
1100 } else {
1101 builder.rs.protos("".parse().unwrap());
1102 }
1103 }
1104 })
1105 .unwrap()
1106 .unwrap_if_sufficient()
1107 .unwrap();
1108 assert_eq!(40, netdir.relays().count());
1110 assert_eq!(
1111 30,
1112 netdir
1113 .relays()
1114 .filter(|r| r.low_level_details().is_suitable_as_guard())
1115 .count()
1116 );
1117 assert_eq!(
1118 20,
1119 netdir
1120 .relays()
1121 .filter(|r| r.low_level_details().is_suitable_as_guard()
1122 && r.low_level_details().is_dir_cache())
1123 .count()
1124 );
1125
1126 let params = GuardParams {
1127 min_filtered_sample_size: 5,
1128 max_sample_bw_fraction: 1.0,
1129 ..GuardParams::default()
1130 };
1131
1132 let mut samples: Vec<HashSet<GuardId>> = Vec::new();
1133 for _ in 0..3 {
1134 let mut guards = GuardSet::default();
1135 guards.extend_sample_as_needed(SystemTime::get(), ¶ms, &netdir);
1136 assert_eq!(guards.guards.len(), params.min_filtered_sample_size);
1137 assert_eq!(guards.confirmed.len(), 0);
1138 assert_eq!(guards.primary.len(), 0);
1139 guards.assert_consistency();
1140
1141 for guard in guards.guards.values() {
1143 let id = FirstHopId::in_sample(GuardSetSelector::Default, guard.guard_id().clone());
1144 let relay = id.get_relay(&netdir).unwrap();
1145 assert!(relay.low_level_details().is_suitable_as_guard());
1146 assert!(relay.low_level_details().is_dir_cache());
1147 assert!(guards.guards.by_all_ids(&relay).is_some());
1148 {
1149 assert!(!guard.is_expired(¶ms, SystemTime::get()));
1150 }
1151 }
1152
1153 guards.extend_sample_as_needed(SystemTime::get(), ¶ms, &netdir);
1155 assert_eq!(guards.guards.len(), params.min_filtered_sample_size);
1156 guards.assert_consistency();
1157
1158 samples.push(guards.sample.into_iter().collect());
1159 }
1160
1161 assert!(samples[0] != samples[1] || samples[1] != samples[2]);
1164 }
1165
1166 #[test]
1167 fn persistence() {
1168 let netdir = netdir();
1169 let params = GuardParams {
1170 min_filtered_sample_size: 5,
1171 ..GuardParams::default()
1172 };
1173
1174 let t1 = SystemTime::get();
1175 let t2 = t1 + Duration::from_secs(20);
1176
1177 let mut guards = GuardSet::default();
1178 guards.extend_sample_as_needed(t1, ¶ms, &netdir);
1179
1180 let id1 = guards.sample[0].clone();
1182 guards.record_success(&id1, ¶ms, None, t2);
1183 assert_eq!(&guards.confirmed, std::slice::from_ref(&id1));
1184
1185 let state: GuardSample = (&guards).into();
1187 let guards2: GuardSet = state.into();
1188
1189 assert_eq!(&guards2.sample, &guards.sample);
1190 assert_eq!(&guards2.confirmed, &guards.confirmed);
1191 assert_eq!(&guards2.confirmed, &[id1]);
1192 assert_eq!(
1193 guards
1194 .guards
1195 .values()
1196 .map(Guard::guard_id)
1197 .collect::<HashSet<_>>(),
1198 guards2
1199 .guards
1200 .values()
1201 .map(Guard::guard_id)
1202 .collect::<HashSet<_>>()
1203 );
1204 for g in guards.guards.values() {
1205 let g2 = guards2.guards.by_all_ids(g.guard_id()).unwrap();
1206 assert_eq!(format!("{:?}", g), format!("{:?}", g2));
1207 }
1208 }
1209
1210 #[test]
1211 fn select_primary() {
1212 let netdir = netdir();
1213 let params = GuardParams {
1214 min_filtered_sample_size: 5,
1215 n_primary: 4,
1216 ..GuardParams::default()
1217 };
1218 let t1 = SystemTime::get();
1219 let t2 = t1 + Duration::from_secs(20);
1220 let t3 = t2 + Duration::from_secs(30);
1221
1222 let mut guards = GuardSet::default();
1223 guards.extend_sample_as_needed(t1, ¶ms, &netdir);
1224
1225 let id3 = guards.sample[3].clone();
1227 guards.record_success(&id3, ¶ms, None, t2);
1228 assert_eq!(&guards.confirmed, std::slice::from_ref(&id3));
1229 let id1 = guards.sample[1].clone();
1230 guards.record_success(&id1, ¶ms, None, t3);
1231 assert_eq!(&guards.confirmed, &[id3.clone(), id1.clone()]);
1232
1233 guards.select_primary_guards(¶ms);
1235 assert_eq!(guards.primary.len(), 4);
1236 assert_eq!(&guards.primary[0], &id3);
1237 assert_eq!(&guards.primary[1], &id1);
1238 let p3 = guards.primary[2].clone();
1239 let p4 = guards.primary[3].clone();
1240 assert_eq!(
1241 [id1.clone(), id3.clone(), p3.clone(), p4.clone()]
1242 .iter()
1243 .unique()
1244 .count(),
1245 4
1246 );
1247
1248 guards.record_success(&p4, ¶ms, None, t3);
1252 assert_eq!(&guards.confirmed, &[id3.clone(), id1.clone(), p4.clone()]);
1253 guards.select_primary_guards(¶ms);
1254 assert_eq!(guards.primary.len(), 4);
1255 assert_eq!(&guards.primary[0], &id3);
1256 assert_eq!(&guards.primary[1], &id1);
1257 assert_eq!(&guards.primary, &[id3, id1, p4, p3]);
1258 }
1259
1260 #[test]
1261 fn expiration() {
1262 let netdir = netdir();
1263 let params = GuardParams::default();
1264 let t1 = SystemTime::get();
1265
1266 let mut guards = GuardSet::default();
1267 guards.extend_sample_as_needed(t1, ¶ms, &netdir);
1268 assert_eq!(guards.sample.len(), 10);
1270
1271 let id1 = guards.sample[0].clone();
1274 guards.record_success(&id1, ¶ms, None, t1);
1275 assert_eq!(&guards.confirmed, &[id1]);
1276
1277 let one_day = Duration::from_secs(86400);
1278 guards.expire_old_guards(¶ms, t1 + one_day * 30);
1279 assert_eq!(guards.sample.len(), 10); guards.expire_old_guards(¶ms, t1 + one_day * 70);
1283 assert_eq!(guards.sample.len(), 9);
1284
1285 guards.expire_old_guards(¶ms, t1 + one_day * 200);
1286 assert_eq!(guards.sample.len(), 0);
1287 }
1288
1289 #[test]
1290 fn sampling_and_usage() {
1291 let netdir = netdir();
1292 let params = GuardParams {
1293 min_filtered_sample_size: 5,
1294 n_primary: 2,
1295 ..GuardParams::default()
1296 };
1297 let st1 = SystemTime::get();
1298 let i1 = Instant::get();
1299 let sec = Duration::from_secs(1);
1300
1301 let mut guards = GuardSet::default();
1302 guards.extend_sample_as_needed(st1, ¶ms, &netdir);
1303 guards.select_primary_guards(¶ms);
1304
1305 let usage = crate::GuardUsageBuilder::default().build().unwrap();
1307 let id1 = guards.primary[0].clone();
1308 let id2 = guards.primary[1].clone();
1309 let (src, id) = guards.pick_guard_id(&usage, ¶ms, i1).unwrap();
1310 assert_eq!(src, ListKind::Primary);
1311 assert_eq!(&id, &id1);
1312
1313 guards.record_attempt(&id, i1);
1314 guards.record_failure(&id, None, i1 + sec);
1315
1316 let (src, id) = guards.pick_guard_id(&usage, ¶ms, i1 + sec).unwrap();
1318 assert_eq!(src, ListKind::Primary);
1319 assert_eq!(&id, &id2);
1320 guards.record_attempt(&id, i1 + sec);
1321
1322 let (src, id_x) = guards.pick_guard_id(&usage, ¶ms, i1 + sec).unwrap();
1323 assert_eq!(id_x, id);
1326 assert_eq!(src, ListKind::Primary);
1327 guards.record_attempt(&id_x, i1 + sec * 2);
1328 guards.record_failure(&id_x, None, i1 + sec * 3);
1329 guards.record_failure(&id, None, i1 + sec * 4);
1330
1331 let (src, id3) = guards.pick_guard_id(&usage, ¶ms, i1 + sec * 4).unwrap();
1333 assert_eq!(src, ListKind::Sample);
1334 assert!(!guards.primary.contains(&id3));
1335 guards.record_attempt(&id3, i1 + sec * 5);
1336
1337 let (src, id4) = guards.pick_guard_id(&usage, ¶ms, i1 + sec * 5).unwrap();
1340 assert_eq!(src, ListKind::Sample);
1341 assert!(id3 != id4);
1342 assert!(!guards.primary.contains(&id4));
1343 guards.record_attempt(&id4, i1 + sec * 6);
1344
1345 assert_eq!(
1350 guards.circ_usability_status(&id1, &usage, ¶ms, i1 + sec * 6),
1351 Some(true)
1352 );
1353 assert_eq!(
1354 guards.circ_usability_status(&id2, &usage, ¶ms, i1 + sec * 6),
1355 Some(true)
1356 );
1357 assert_eq!(
1358 guards.circ_usability_status(&id3, &usage, ¶ms, i1 + sec * 6),
1359 Some(true)
1360 );
1361 assert_eq!(
1362 guards.circ_usability_status(&id4, &usage, ¶ms, i1 + sec * 6),
1363 None
1364 );
1365
1366 guards.record_success(&id3, ¶ms, None, st1 + sec * 7);
1368 guards.record_success(&id4, ¶ms, None, st1 + sec * 8);
1369
1370 assert!(guards.primary_guards_invalidated);
1372 guards.select_primary_guards(¶ms);
1373 assert_eq!(&guards.primary, &[id3.clone(), id4.clone()]);
1374
1375 let (src, id) = guards
1377 .pick_guard_id(&usage, ¶ms, i1 + sec * 10)
1378 .unwrap();
1379 assert_eq!(src, ListKind::Primary);
1380 assert_eq!(&id, &id3);
1381
1382 let mut found = HashSet::new();
1384 let usage = crate::GuardUsageBuilder::default()
1385 .kind(crate::GuardUsageKind::OneHopDirectory)
1386 .build()
1387 .unwrap();
1388 for _ in 0..64 {
1389 let (src, id) = guards
1390 .pick_guard_id(&usage, ¶ms, i1 + sec * 10)
1391 .unwrap();
1392 assert_eq!(src, ListKind::Primary);
1393 assert_eq!(
1394 guards.circ_usability_status(&id, &usage, ¶ms, i1 + sec * 10),
1395 Some(true)
1396 );
1397 guards.record_attempt_abandoned(&id);
1398 found.insert(id);
1399 }
1400 assert!(found.len() == 2);
1401 assert!(found.contains(&id3));
1402 assert!(found.contains(&id4));
1403
1404 assert_eq!(
1406 guards.circ_usability_status(&id1, &usage, ¶ms, i1 + sec * 12),
1407 Some(false)
1408 );
1409 assert_eq!(
1410 guards.circ_usability_status(&id2, &usage, ¶ms, i1 + sec * 12),
1411 Some(false)
1412 );
1413 }
1414
1415 #[test]
1416 fn everybodys_down() {
1417 let netdir = netdir();
1418 let params = GuardParams {
1419 min_filtered_sample_size: 5,
1420 n_primary: 2,
1421 max_sample_bw_fraction: 1.0,
1422 ..GuardParams::default()
1423 };
1424 let mut st = SystemTime::get();
1425 let mut inst = Instant::get();
1426 let sec = Duration::from_secs(1);
1427 let usage = crate::GuardUsageBuilder::default().build().unwrap();
1428
1429 let mut guards = GuardSet::default();
1430
1431 guards.extend_sample_as_needed(st, ¶ms, &netdir);
1432 guards.select_primary_guards(¶ms);
1433
1434 assert_eq!(guards.sample.len(), 5);
1435 for _ in 0..5 {
1436 let (_, id) = guards.pick_guard_id(&usage, ¶ms, inst).unwrap();
1437 guards.record_attempt(&id, inst);
1438 guards.record_failure(&id, None, inst + sec);
1439
1440 inst += sec * 2;
1441 st += sec * 2;
1442 }
1443
1444 let e = guards.pick_guard_id(&usage, ¶ms, inst);
1445 assert!(matches!(e, Err(PickGuardError::AllGuardsDown { .. })));
1446
1447 guards.extend_sample_as_needed(st, ¶ms, &netdir);
1449 guards.select_primary_guards(¶ms);
1450 assert_eq!(guards.sample.len(), 10);
1451 }
1452
1453 #[test]
1454 fn retry_primary() {
1455 let netdir = netdir();
1456 let params = GuardParams {
1457 min_filtered_sample_size: 5,
1458 n_primary: 2,
1459 max_sample_bw_fraction: 1.0,
1460 ..GuardParams::default()
1461 };
1462 let usage = crate::GuardUsageBuilder::default().build().unwrap();
1463
1464 let mut guards = GuardSet::default();
1465
1466 guards.extend_sample_as_needed(SystemTime::get(), ¶ms, &netdir);
1467 guards.select_primary_guards(¶ms);
1468
1469 assert_eq!(guards.primary.len(), 2);
1470 assert!(!guards.all_primary_guards_are_unreachable());
1471
1472 let (kind, p_id1) = guards
1474 .pick_guard_id(&usage, ¶ms, Instant::get())
1475 .unwrap();
1476 assert_eq!(kind, ListKind::Primary);
1477 guards.record_failure(&p_id1, None, Instant::get());
1478 assert!(!guards.all_primary_guards_are_unreachable());
1479
1480 let (kind, p_id2) = guards
1482 .pick_guard_id(&usage, ¶ms, Instant::get())
1483 .unwrap();
1484 assert_eq!(kind, ListKind::Primary);
1485 guards.record_failure(&p_id2, None, Instant::get());
1486 assert!(guards.all_primary_guards_are_unreachable());
1487
1488 guards.mark_primary_guards_retriable();
1490 assert!(!guards.all_primary_guards_are_unreachable());
1491 let (kind, p_id3) = guards
1492 .pick_guard_id(&usage, ¶ms, Instant::get())
1493 .unwrap();
1494 assert_eq!(kind, ListKind::Primary);
1495 assert_eq!(p_id3, p_id1);
1496 }
1497
1498 #[test]
1499 fn count_missing_mds() {
1500 let netdir = netdir();
1501 let params = GuardParams {
1502 min_filtered_sample_size: 5,
1503 n_primary: 2,
1504 max_sample_bw_fraction: 1.0,
1505 ..GuardParams::default()
1506 };
1507 let usage = crate::GuardUsageBuilder::default().build().unwrap();
1508 let mut guards = GuardSet::default();
1509 guards.extend_sample_as_needed(SystemTime::get(), ¶ms, &netdir);
1510 guards.select_primary_guards(¶ms);
1511 assert_eq!(guards.primary.len(), 2);
1512
1513 let (_kind, p_id1) = guards
1514 .pick_guard_id(&usage, ¶ms, Instant::get())
1515 .unwrap();
1516 guards.record_success(&p_id1, ¶ms, None, SystemTime::get());
1517 assert_eq!(guards.n_primary_without_id_info_in(&netdir), 0);
1518
1519 use tor_netdir::testnet;
1520 let netdir2 = testnet::construct_custom_netdir(|_idx, bld, _| {
1521 let md_so_far = bld.md.testing_md().expect("Couldn't build md?");
1522 if &p_id1.0.identity(RelayIdType::Ed25519).unwrap() == md_so_far.ed25519_id() {
1523 bld.omit_md = true;
1524 }
1525 })
1526 .unwrap()
1527 .unwrap_if_sufficient()
1528 .unwrap();
1529
1530 assert_eq!(guards.n_primary_without_id_info_in(&netdir2), 1);
1531 }
1532
1533 #[test]
1534 fn copy_status() {
1535 let netdir = netdir();
1536 let params = GuardParams {
1537 min_filtered_sample_size: 5,
1538 n_primary: 2,
1539 max_sample_bw_fraction: 1.0,
1540 ..GuardParams::default()
1541 };
1542 let mut guards1 = GuardSet::default();
1543 guards1.extend_sample_as_needed(SystemTime::get(), ¶ms, &netdir);
1544 guards1.select_primary_guards(¶ms);
1545 let mut guards2 = guards1.clone();
1546
1547 let id1 = guards1.primary[0].clone();
1549 let id2 = guards1.primary[1].clone();
1550 guards1.record_success(&id1, ¶ms, None, SystemTime::get());
1551 guards2.record_success(&id2, ¶ms, None, SystemTime::get());
1552 guards2.record_failure(&id2, None, Instant::get());
1554
1555 guards1.copy_ephemeral_status_into_newly_loaded_state(guards2);
1557 {
1558 let g1 = guards1.get(&id1).unwrap();
1559 let g2 = guards1.get(&id2).unwrap();
1560 assert!(g1.confirmed());
1561 assert!(!g2.confirmed());
1562 assert_eq!(g1.reachable(), Reachable::Untried);
1563 assert_eq!(g2.reachable(), Reachable::Unreachable);
1564 }
1565
1566 let mut guards3 = GuardSet::default();
1569 let g1_set: HashSet<_> = guards1
1570 .guards
1571 .values()
1572 .map(|g| g.guard_id().clone())
1573 .collect();
1574 let mut g3_set: HashSet<_> = HashSet::new();
1575 for _ in 0..4 {
1576 guards3.extend_sample_as_needed(SystemTime::get(), ¶ms, &netdir);
1579 guards3.select_primary_guards(¶ms);
1580 g3_set = guards3
1581 .guards
1582 .values()
1583 .map(|g| g.guard_id().clone())
1584 .collect();
1585
1586 if g1_set == g3_set {
1588 guards3 = GuardSet::default();
1589 continue;
1590 }
1591 break;
1592 }
1593 assert_ne!(g1_set, g3_set);
1594 guards1.copy_ephemeral_status_into_newly_loaded_state(guards3);
1596 let g1_set_new: HashSet<_> = guards1
1597 .guards
1598 .values()
1599 .map(|g| g.guard_id().clone())
1600 .collect();
1601 assert_eq!(g1_set, g1_set_new);
1602 }
1603
1604 #[test]
1605 #[cfg(feature = "bridge-client")]
1607 fn partial_identity_collision() {
1608 use crate::bridge::BridgeSet;
1609 use std::sync::Arc;
1610 let bc = Arc::new([
1613 "192.168.0.1:80 $0bac39417268b69b9f514e7f63fa6fba1a788958
1614 ed25519:S2Fya2F0ICBXaGF0ICBJcyAgSGUgIERvaW5nIEhlcmU"
1615 .parse()
1616 .unwrap(),
1617 "192.168.0.2:80 $0bac39417268b69b9f514e7f63fa6fba1a788958
1618 ed25519:dGhpcyBpcyBbpmNyZWRpYmx5IHNpbGx5ISEhISEhISA"
1619 .parse()
1620 .unwrap(),
1621 ]);
1622 let bs = BridgeSet::new(bc, None);
1623 let mut gs = GuardSet::default();
1627 let params = GuardParams::default();
1628 assert!(params.max_sample_size >= 2);
1629 assert_eq!(gs.active_filter, GuardFilter::unfiltered());
1630 gs.extend_sample_as_needed(SystemTime::get(), ¶ms, &bs);
1631 gs.assert_consistency();
1632 }
1633}