1use std::{
2 fmt::{Display, Formatter},
3 net::ToSocketAddrs,
4 num::ParseIntError,
5 str::FromStr,
6 time::Duration,
7};
8
9use hopr_api::Multiaddr;
10pub use hopr_protocol_hopr::{
11 HoprCodecConfig, HoprUnacknowledgedTicketProcessorConfig, ReplayFilterConfig, SurbPopOrder, SurbStoreConfig,
12};
13use hopr_protocol_pix::SsaReconstructorConfig;
14pub use hopr_transport_mixer::config::MixerConfig;
15pub use hopr_transport_probe::config::ProbeConfig;
16use hopr_transport_session::{
17 DEFAULT_MAX_SSAS_PER_SSA_REQUEST, DEFAULT_PIX_POLYS_PER_SSA, DEFAULT_PIX_SHARES_PER_POLY, IncomingSessionPixConfig,
18 MAX_ASSUMED_SESSION_PACKET_RATE, MIN_BALANCER_SAMPLING_INTERVAL, MIN_REFUSAL_REPLY_REFILL_PERIOD,
19 MIN_SURB_BUFFER_DURATION, RefusalReplyBudget,
20};
21use proc_macro_regex::regex;
22use validator::{Validate, ValidationError, ValidationErrors};
23
24use crate::{errors::HoprTransportError, protocol::PacketPipelineConfig};
25
26const DEFAULT_COUNTER_FLUSH_INTERVAL: Duration = Duration::from_secs(15);
27
28const DEFAULT_PER_PEER_CHANNEL_CAPACITY: usize = 5_000;
29const DEFAULT_STREAM_OPEN_TIMEOUT: Duration = Duration::from_secs(2);
30const DEFAULT_FRAME_WRITER_BACKPRESSURE_BYTES: usize = 131_072;
31const DEFAULT_EGRESS_BACKPRESSURE_TIMEOUT: Duration = Duration::from_secs(2);
32
33pub const MIN_STREAM_OPEN_TIMEOUT: Duration = Duration::from_millis(1);
35
36pub const MIN_EGRESS_BACKPRESSURE_TIMEOUT: Duration = Duration::from_millis(1);
38
39fn default_per_peer_channel_capacity() -> usize {
40 DEFAULT_PER_PEER_CHANNEL_CAPACITY
41}
42
43fn default_stream_open_timeout() -> Duration {
44 DEFAULT_STREAM_OPEN_TIMEOUT
45}
46
47fn default_frame_writer_backpressure_bytes() -> usize {
48 DEFAULT_FRAME_WRITER_BACKPRESSURE_BYTES
49}
50
51#[inline]
52fn default_egress_backpressure_timeout() -> Duration {
53 DEFAULT_EGRESS_BACKPRESSURE_TIMEOUT
54}
55
56fn validate_stream_open_timeout(value: &Duration) -> Result<(), ValidationError> {
57 if MIN_STREAM_OPEN_TIMEOUT <= *value {
58 Ok(())
59 } else {
60 Err(ValidationError::new("stream open timeout must be at least 1 ms"))
61 }
62}
63
64fn validate_egress_backpressure_timeout(value: &Duration) -> Result<(), ValidationError> {
65 if MIN_EGRESS_BACKPRESSURE_TIMEOUT <= *value {
66 Ok(())
67 } else {
68 Err(ValidationError::new(
71 "egress backpressure timeout must be at least 1 ms",
72 ))
73 }
74}
75
76#[derive(Debug, Clone, Copy, PartialEq, Eq, Validate, smart_default::SmartDefault)]
78#[cfg_attr(
79 feature = "serde",
80 derive(serde::Serialize, serde::Deserialize),
81 serde(deny_unknown_fields)
82)]
83pub struct StreamProtocolConfig {
84 #[validate(range(min = 1))]
107 #[default(default_per_peer_channel_capacity())]
108 #[cfg_attr(feature = "serde", serde(default = "default_per_peer_channel_capacity"))]
109 pub per_peer_channel_capacity: usize,
110
111 #[validate(custom(function = "validate_stream_open_timeout"))]
122 #[default(default_stream_open_timeout())]
123 #[cfg_attr(
124 feature = "serde",
125 serde(default = "default_stream_open_timeout", with = "humantime_serde")
126 )]
127 pub stream_open_timeout: Duration,
128
129 #[validate(range(min = 1))]
139 #[default(default_frame_writer_backpressure_bytes())]
140 #[cfg_attr(feature = "serde", serde(default = "default_frame_writer_backpressure_bytes"))]
141 pub frame_writer_backpressure_bytes: usize,
142
143 #[validate(custom(function = "validate_egress_backpressure_timeout"))]
155 #[default(default_egress_backpressure_timeout())]
156 #[cfg_attr(feature = "serde", serde(default = "default_egress_backpressure_timeout"))]
157 pub egress_backpressure_timeout: Duration,
158}
159
160fn default_counter_flush_interval() -> Duration {
161 DEFAULT_COUNTER_FLUSH_INTERVAL
162}
163
164const DEFAULT_SURB_FLUSH_INTERVAL: Duration = Duration::from_secs(1);
171
172fn default_surb_flush_interval() -> Duration {
173 DEFAULT_SURB_FLUSH_INTERVAL
174}
175
176#[derive(Debug, Clone, Copy, PartialEq, Eq, smart_default::SmartDefault)]
187#[cfg_attr(
188 feature = "serde",
189 derive(serde::Serialize, serde::Deserialize),
190 serde(deny_unknown_fields)
191)]
192pub struct TransitLatencyConfig {
193 #[default(Duration::from_millis(50))]
195 #[cfg_attr(feature = "serde", serde(with = "humantime_serde"))]
196 pub mean: Duration,
197 #[default(Duration::from_millis(5))]
201 #[cfg_attr(feature = "serde", serde(with = "humantime_serde"))]
202 pub std_dev: Duration,
203}
204
205#[derive(Debug, smart_default::SmartDefault, Validate, Clone, PartialEq)]
207#[cfg_attr(
208 feature = "serde",
209 derive(serde::Serialize, serde::Deserialize),
210 serde(deny_unknown_fields)
211)]
212#[validate(schema(function = "validate_pix_supervision_pairing", skip_on_field_errors = false))]
213pub struct HoprProtocolConfig {
214 #[validate(nested)]
216 #[cfg_attr(feature = "serde", serde(default))]
217 pub transport: TransportConfig,
218 #[validate(nested)]
220 #[cfg_attr(feature = "serde", serde(default))]
221 pub packet: HoprPacketPipelineConfig,
222 #[validate(nested)]
224 #[cfg_attr(feature = "serde", serde(default))]
225 pub probe: ProbeConfig,
226 #[validate(nested)]
228 #[cfg_attr(feature = "serde", serde(default))]
229 pub session: SessionGlobalConfig,
230 #[validate(nested)]
232 #[cfg_attr(feature = "serde", serde(default))]
233 pub pix: PixGlobalConfig,
234 #[validate(custom(function = "validate_incoming_session_pix_config"))]
236 #[cfg_attr(feature = "serde", serde(default))]
237 pub incoming_session_pix_config: IncomingSessionPixConfig,
238 #[validate(nested)]
240 #[cfg_attr(feature = "serde", serde(default))]
241 pub mixer: MixerConfig,
242 #[cfg_attr(feature = "serde", serde(default))]
248 pub transit_latency: Option<TransitLatencyConfig>,
249 #[validate(nested)]
251 #[cfg_attr(feature = "serde", serde(default))]
252 pub stream: StreamProtocolConfig,
253 #[validate(nested)]
255 #[cfg_attr(feature = "serde", serde(default))]
256 pub path_planner: crate::path::PathPlannerConfig,
257 #[default(default_counter_flush_interval())]
262 #[cfg_attr(
263 feature = "serde",
264 serde(default = "default_counter_flush_interval", with = "humantime_serde")
265 )]
266 pub counter_flush_interval: Duration,
267 #[default(default_surb_flush_interval())]
271 #[cfg_attr(
272 feature = "serde",
273 serde(default = "default_surb_flush_interval", with = "humantime_serde")
274 )]
275 pub surb_flush_interval: Duration,
276 #[default(default_latency_race_memory())]
280 #[cfg_attr(feature = "serde", serde(default = "default_latency_race_memory"))]
281 pub latency_race_memory: u32,
282 #[default(default_relayer_health_weight())]
286 #[validate(custom(function = "validate_relayer_health_weight"))]
287 #[cfg_attr(feature = "serde", serde(default = "default_relayer_health_weight"))]
288 pub relayer_health_weight: f64,
289}
290
291fn default_latency_race_memory() -> u32 {
292 4
293}
294
295fn default_relayer_health_weight() -> f64 {
296 1.0
297}
298
299fn validate_relayer_health_weight(value: f64) -> Result<(), ValidationError> {
303 if value.is_finite() && value >= 0.0 {
304 Ok(())
305 } else {
306 Err(ValidationError::new(
307 "relayer health weight must be finite and non-negative",
308 ))
309 }
310}
311
312fn validate_pix_supervision_pairing(cfg: &HoprProtocolConfig) -> Result<(), ValidationError> {
329 hopr_transport_session::validate_pix_supervision(
330 &cfg.incoming_session_pix_config.supervisor_config(),
331 &cfg.pix.reconstructor.into(),
332 )
333 .map_err(|error| {
334 let mut e = ValidationError::new("pix supervision deadlines conflict with the reconstructor's lifetimes");
335 e.message = Some(error.to_string().into());
336 e
337 })
338}
339
340fn validate_incoming_session_pix_config(cfg: &IncomingSessionPixConfig) -> Result<(), ValidationError> {
361 hopr_transport_session::validate_incoming_session_pix_config(cfg, MAX_ASSUMED_SESSION_PACKET_RATE).map_err(
362 |error| {
363 let mut e = ValidationError::new("invalid incoming PIX configuration");
364 e.message = Some(error.to_string().into());
365 e
366 },
367 )
368}
369
370#[derive(Clone, Copy, Debug, PartialEq, Validate, smart_default::SmartDefault)]
372#[cfg_attr(
373 feature = "serde",
374 derive(serde::Serialize, serde::Deserialize),
375 serde(default, deny_unknown_fields)
376)]
377pub struct PixGlobalConfig {
378 #[validate(range(min = 8, max = 16192))]
394 #[default(DEFAULT_PIX_POLYS_PER_SSA as usize)]
395 pub num_ssa_parts: usize,
396
397 #[validate(range(min = 2, max = 255))]
407 #[default(DEFAULT_PIX_SHARES_PER_POLY as usize)]
408 pub ssa_part_size: usize,
409
410 #[validate(range(min = 0, max = 255))]
442 pub additional_shares: Option<usize>,
443
444 #[validate(range(min = 1, max = 9))]
461 #[default(DEFAULT_MAX_SSAS_PER_SSA_REQUEST)]
462 pub max_ssas_per_request: usize,
463
464 #[validate(nested)]
469 #[cfg_attr(feature = "serde", serde(default))]
470 pub reconstructor: PixReconstructorConfig,
471}
472
473impl PixGlobalConfig {
474 pub fn surplus_shares(&self) -> usize {
482 self.additional_shares.unwrap_or_else(|| {
483 hopr_protocol_pix::default_surplus_for(
484 self.num_ssa_parts.min(u16::MAX as usize) as u16,
485 self.ssa_part_size.min(u8::MAX as usize) as u8,
486 ) as usize
487 })
488 }
489}
490
491fn validate_pix_reconstructor_config(cfg: &PixReconstructorConfig) -> Result<(), ValidationError> {
502 SsaReconstructorConfig::from(*cfg).validate().map_err(|errors| {
503 let mut error = ValidationError::new("pix reconstructor configuration is out of range");
504 error.message = Some(errors.to_string().into());
505 error
506 })
507}
508
509#[derive(Clone, Copy, Debug, PartialEq, Validate, smart_default::SmartDefault)]
530#[cfg_attr(
531 feature = "serde",
532 derive(serde::Serialize, serde::Deserialize),
533 serde(default, deny_unknown_fields)
534)]
535#[validate(schema(function = "validate_pix_reconstructor_config", skip_on_field_errors = false))]
536pub struct PixReconstructorConfig {
537 #[default(SsaReconstructorConfig::DEFAULT_INCOMPLETE_COMMITMENT_LIFETIME)]
542 #[cfg_attr(feature = "serde", serde(with = "humantime_serde"))]
543 pub incomplete_commitment_lifetime: Duration,
544
545 #[default(SsaReconstructorConfig::DEFAULT_UNUSED_VERIFIER_LIFETIME)]
549 #[cfg_attr(feature = "serde", serde(with = "humantime_serde"))]
550 pub unused_verifier_lifetime: Duration,
551
552 #[default(SsaReconstructorConfig::DEFAULT_MAX_TRACKED_PEERS)]
556 pub max_tracked_peers: usize,
557
558 #[default(SsaReconstructorConfig::DEFAULT_MAX_AWAITING_ACKS)]
562 pub max_awaiting_acks: usize,
563
564 #[default(SsaReconstructorConfig::DEFAULT_MAX_ACK_AWAIT_TIME)]
568 #[cfg_attr(feature = "serde", serde(with = "humantime_serde"))]
569 pub max_ack_await_time: Duration,
570
571 #[default(SsaReconstructorConfig::DEFAULT_USE_BATCH_VERIFICATION)]
576 pub use_batch_verification: bool,
577
578 #[default(SsaReconstructorConfig::DEFAULT_EARLY_RECOVERY_THRESHOLD)]
583 pub early_recovery_threshold: f64,
584
585 #[default(SsaReconstructorConfig::DEFAULT_MAX_ACK_BUFFER_BYTES)]
599 pub max_ack_buffer_bytes: usize,
600}
601
602impl From<PixReconstructorConfig> for SsaReconstructorConfig {
603 fn from(cfg: PixReconstructorConfig) -> Self {
610 let PixReconstructorConfig {
611 incomplete_commitment_lifetime,
612 unused_verifier_lifetime,
613 max_tracked_peers,
614 max_awaiting_acks,
615 max_ack_await_time,
616 use_batch_verification,
617 early_recovery_threshold,
618 max_ack_buffer_bytes,
619 } = cfg;
620
621 Self {
622 incomplete_commitment_lifetime,
623 unused_verifier_lifetime,
624 max_tracked_peers,
625 max_awaiting_acks,
626 max_ack_await_time,
627 use_batch_verification,
628 early_recovery_threshold,
629 max_ack_buffer_bytes,
630 }
631 }
632}
633
634#[derive(Clone, Copy, Debug, PartialEq, Validate, smart_default::SmartDefault)]
636#[cfg_attr(
637 feature = "serde",
638 derive(serde::Serialize, serde::Deserialize),
639 serde(deny_unknown_fields)
640)]
641pub struct HoprPacketPipelineConfig {
642 #[validate(nested)]
644 #[cfg_attr(feature = "serde", serde(default))]
645 pub codec: HoprCodecConfig,
646 #[validate(nested)]
648 #[cfg_attr(feature = "serde", serde(default))]
649 pub ack_processor: HoprUnacknowledgedTicketProcessorConfig,
650 #[validate(nested)]
652 #[cfg_attr(feature = "serde", serde(default))]
653 pub surb_store: SurbStoreConfig,
654 #[validate(nested)]
656 #[cfg_attr(feature = "serde", serde(default))]
657 pub pipeline: PacketPipelineConfig,
658}
659
660regex!(is_dns_address_regex "^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\\.)*[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$");
661
662#[inline]
664pub fn looks_like_domain(s: &str) -> bool {
665 is_dns_address_regex(s)
666}
667
668pub fn is_reachable_domain(host: &str) -> bool {
670 host.to_socket_addrs().is_ok_and(|i| i.into_iter().next().is_some())
671}
672
673#[derive(Debug, Clone, PartialEq)]
675#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
676pub enum HostType {
677 IPv4(String),
679 Domain(String),
681}
682
683impl validator::Validate for HostType {
684 fn validate(&self) -> Result<(), ValidationErrors> {
685 match &self {
686 HostType::IPv4(ip4) => validate_ipv4_address(ip4).map_err(|e| {
687 let mut errs = ValidationErrors::new();
688 errs.add("ipv4", e);
689 errs
690 }),
691 HostType::Domain(domain) => validate_dns_address(domain).map_err(|e| {
692 let mut errs = ValidationErrors::new();
693 errs.add("domain", e);
694 errs
695 }),
696 }
697 }
698}
699
700impl Default for HostType {
701 fn default() -> Self {
702 HostType::IPv4("127.0.0.1".to_owned())
703 }
704}
705
706#[derive(Debug, Validate, Clone, PartialEq)]
712#[cfg_attr(
713 feature = "serde",
714 derive(serde::Serialize, serde::Deserialize),
715 serde(deny_unknown_fields)
716)]
717pub struct HostConfig {
718 #[cfg_attr(feature = "serde", serde(default))]
720 pub address: HostType,
721 #[validate(range(min = 1u16))]
723 #[cfg_attr(feature = "serde", serde(default))]
724 pub port: u16,
725}
726
727impl FromStr for HostConfig {
728 type Err = String;
729
730 fn from_str(s: &str) -> Result<Self, Self::Err> {
731 let (ip_or_dns, str_port) = match s.split_once(':') {
732 None => return Err("Invalid host, is not in the '<host>:<port>' format".into()),
733 Some(split) => split,
734 };
735
736 let port = str_port.parse().map_err(|e: ParseIntError| e.to_string())?;
737
738 if validator::ValidateIp::validate_ipv4(&ip_or_dns) {
739 Ok(Self {
740 address: HostType::IPv4(ip_or_dns.to_owned()),
741 port,
742 })
743 } else if looks_like_domain(ip_or_dns) {
744 Ok(Self {
745 address: HostType::Domain(ip_or_dns.to_owned()),
746 port,
747 })
748 } else {
749 Err("Not a valid IPv4 or domain host".into())
750 }
751 }
752}
753
754impl Display for HostConfig {
755 fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
756 write!(f, "{:?}:{}", self.address, self.port)
757 }
758}
759
760fn default_multiaddr_transport(port: u16) -> String {
761 cfg_if::cfg_if! {
762 if #[cfg(feature = "p2p-announce-quic")] {
763 let on_dappnode = std::env::var("DAPPNODE")
767 .map(|v| v.to_lowercase() == "true")
768 .unwrap_or(false);
769
770 let uses_nat = std::env::var("HOPRD_NAT")
772 .map(|v| v.to_lowercase() == "true")
773 .unwrap_or(on_dappnode);
774
775 if uses_nat {
776 format!("tcp/{port}")
777 } else {
778 format!("udp/{port}/quic-v1")
779 }
780 } else {
781 format!("tcp/{port}")
782 }
783 }
784}
785
786impl TryFrom<&HostConfig> for Multiaddr {
787 type Error = HoprTransportError;
788
789 fn try_from(value: &HostConfig) -> Result<Self, Self::Error> {
790 match &value.address {
791 HostType::IPv4(ip) => Multiaddr::from_str(
792 format!("/ip4/{}/{}", ip.as_str(), default_multiaddr_transport(value.port)).as_str(),
793 )
794 .map_err(|e| HoprTransportError::Api(e.to_string())),
795 HostType::Domain(domain) => Multiaddr::from_str(
796 format!("/dns4/{}/{}", domain.as_str(), default_multiaddr_transport(value.port)).as_str(),
797 )
798 .map_err(|e| HoprTransportError::Api(e.to_string())),
799 }
800 }
801}
802
803fn validate_ipv4_address(s: &str) -> Result<(), ValidationError> {
804 if validator::ValidateIp::validate_ipv4(&s) {
805 let ipv4 = std::net::Ipv4Addr::from_str(s)
806 .map_err(|_| ValidationError::new("Failed to deserialize the string into an ipv4 address"))?;
807
808 if ipv4.is_private() || ipv4.is_multicast() || ipv4.is_unspecified() {
809 return Err(ValidationError::new(
810 "IPv4 cannot be private, multicast or unspecified (0.0.0.0)",
811 ))?;
812 }
813 Ok(())
814 } else {
815 Err(ValidationError::new("Invalid IPv4 address provided"))
816 }
817}
818
819fn validate_dns_address(s: &str) -> Result<(), ValidationError> {
820 if looks_like_domain(s) || is_reachable_domain(s) {
821 Ok(())
822 } else {
823 Err(ValidationError::new("Invalid DNS address provided"))
824 }
825}
826
827#[derive(Debug, Default, Validate, Clone, Copy, PartialEq)]
829#[cfg_attr(
830 feature = "serde",
831 derive(serde::Serialize, serde::Deserialize),
832 serde(deny_unknown_fields)
833)]
834pub struct TransportConfig {
835 #[cfg_attr(feature = "serde", serde(default))]
838 pub announce_local_addresses: bool,
839 #[cfg_attr(feature = "serde", serde(default))]
842 pub prefer_local_addresses: bool,
843}
844
845const DEFAULT_SESSION_IDLE_TIMEOUT: Duration = Duration::from_mins(3);
846
847const SESSION_IDLE_MIN_TIMEOUT: Duration = Duration::from_secs(2);
848
849const DEFAULT_SESSION_ESTABLISH_RETRY_DELAY: Duration = Duration::from_secs(2);
850
851const DEFAULT_SESSION_ESTABLISH_MAX_RETRIES: usize = 3;
852
853const DEFAULT_SESSION_BALANCER_SAMPLING: Duration = Duration::from_millis(100);
854
855const DEFAULT_SESSION_BALANCER_BUFFER_DURATION: Duration = Duration::from_secs(5);
856
857const DEFAULT_MAXIMUM_MANAGED_SESSIONS: usize = 100;
858
859fn default_session_balancer_buffer_duration() -> Duration {
860 DEFAULT_SESSION_BALANCER_BUFFER_DURATION
861}
862
863fn default_session_establish_max_retries() -> usize {
864 DEFAULT_SESSION_ESTABLISH_MAX_RETRIES
865}
866
867fn default_session_idle_timeout() -> Duration {
868 DEFAULT_SESSION_IDLE_TIMEOUT
869}
870
871fn default_session_establish_retry_delay() -> Duration {
872 DEFAULT_SESSION_ESTABLISH_RETRY_DELAY
873}
874
875fn default_session_balancer_sampling() -> Duration {
876 DEFAULT_SESSION_BALANCER_SAMPLING
877}
878
879fn default_max_managed_sessions() -> usize {
880 DEFAULT_MAXIMUM_MANAGED_SESSIONS
881}
882
883fn default_session_surb_balance_notify_period() -> Option<Duration> {
891 Some(Duration::from_secs(15))
892}
893
894fn default_session_surb_degraded_notify_period() -> Option<Duration> {
899 Some(Duration::from_secs(1))
900}
901
902fn default_session_surb_idle_notify_period() -> Option<Duration> {
904 Some(Duration::from_secs(45))
905}
906
907fn default_session_refusal_reply_budget() -> Option<RefusalReplyBudget> {
909 Some(RefusalReplyBudget::default())
910}
911
912fn default_session_max_frames_behind_gap() -> Option<usize> {
913 Some(256)
914}
915
916fn default_session_surb_target_notify() -> bool {
917 true
918}
919
920fn validate_session_idle_timeout(value: &Duration) -> Result<(), ValidationError> {
921 if SESSION_IDLE_MIN_TIMEOUT <= *value {
922 Ok(())
923 } else {
924 Err(ValidationError::new("session idle timeout is too low"))
925 }
926}
927
928fn validate_balancer_sampling(value: &Duration) -> Result<(), ValidationError> {
929 if MIN_BALANCER_SAMPLING_INTERVAL <= *value {
930 Ok(())
931 } else {
932 Err(ValidationError::new("balancer sampling interval is too low"))
933 }
934}
935
936fn validate_balancer_buffer_duration(value: &Duration) -> Result<(), ValidationError> {
937 if MIN_SURB_BUFFER_DURATION <= *value {
938 Ok(())
939 } else {
940 Err(ValidationError::new("minmum SURB buffer duration is too low"))
941 }
942}
943
944fn validate_surb_balance_notify_period(value: &Duration) -> Result<(), ValidationError> {
945 if *value >= Duration::from_secs(1) {
947 Ok(())
948 } else {
949 Err(ValidationError::new(
950 "SURB balance notify period must be at least 1 second",
951 ))
952 }
953}
954
955fn validate_surb_degraded_notify_period(value: &Duration) -> Result<(), ValidationError> {
956 if *value >= Duration::from_secs(1) {
957 Ok(())
958 } else {
959 Err(ValidationError::new(
960 "SURB degraded notify period must be at least 1 second",
961 ))
962 }
963}
964
965fn validate_surb_idle_notify_period(value: &Duration) -> Result<(), ValidationError> {
966 if *value >= Duration::from_secs(1) {
967 Ok(())
968 } else {
969 Err(ValidationError::new(
970 "SURB idle notify period must be at least 1 second",
971 ))
972 }
973}
974
975fn validate_refusal_reply_budget(value: &RefusalReplyBudget) -> Result<(), ValidationError> {
976 if value.refill_period >= MIN_REFUSAL_REPLY_REFILL_PERIOD {
977 Ok(())
978 } else {
979 Err(ValidationError::new(
980 "refusal reply budget refill period must be at least 1 millisecond",
981 ))
982 }
983}
984
985#[derive(Clone, Copy, Debug, PartialEq, Eq, Validate, smart_default::SmartDefault)]
987#[cfg_attr(
988 feature = "serde",
989 derive(serde::Serialize, serde::Deserialize),
990 serde(deny_unknown_fields)
991)]
992pub struct SessionGlobalConfig {
993 #[validate(custom(function = "validate_session_idle_timeout"))]
997 #[default(default_session_idle_timeout())]
998 #[cfg_attr(
999 feature = "serde",
1000 serde(default = "default_session_idle_timeout", with = "humantime_serde")
1001 )]
1002 pub idle_timeout: Duration,
1003
1004 #[validate(range(min = 2, max = 100_000))]
1008 #[default(default_max_managed_sessions())]
1009 #[cfg_attr(feature = "serde", serde(default = "default_max_managed_sessions"))]
1010 pub maximum_managed_sessions: usize,
1011
1012 #[validate(range(min = 0, max = 20))]
1017 #[default(default_session_establish_max_retries())]
1018 #[cfg_attr(feature = "serde", serde(default = "default_session_establish_max_retries"))]
1019 pub establish_max_retries: usize,
1020
1021 #[default(default_session_establish_retry_delay())]
1025 #[cfg_attr(
1026 feature = "serde",
1027 serde(default = "default_session_establish_retry_delay", with = "humantime_serde")
1028 )]
1029 pub establish_retry_timeout: Duration,
1030
1031 #[validate(custom(function = "validate_balancer_sampling"))]
1035 #[default(default_session_balancer_sampling())]
1036 #[cfg_attr(
1037 feature = "serde",
1038 serde(default = "default_session_balancer_sampling", with = "humantime_serde")
1039 )]
1040 pub balancer_sampling_interval: Duration,
1041
1042 #[validate(custom(function = "validate_balancer_buffer_duration"))]
1050 #[default(default_session_balancer_buffer_duration())]
1051 #[cfg_attr(
1052 feature = "serde",
1053 serde(default = "default_session_balancer_buffer_duration", with = "humantime_serde")
1054 )]
1055 pub balancer_minimum_surb_buffer_duration: Duration,
1056
1057 #[validate(custom(function = "validate_surb_balance_notify_period"))]
1068 #[default(default_session_surb_balance_notify_period())]
1069 #[cfg_attr(
1070 feature = "serde",
1071 serde(
1072 default = "default_session_surb_balance_notify_period",
1073 with = "humantime_serde::option"
1074 )
1075 )]
1076 pub surb_balance_notify_period: Option<Duration>,
1077
1078 #[validate(custom(function = "validate_surb_degraded_notify_period"))]
1109 #[default(default_session_surb_degraded_notify_period())]
1110 #[cfg_attr(
1111 feature = "serde",
1112 serde(
1113 default = "default_session_surb_degraded_notify_period",
1114 with = "humantime_serde::option"
1115 )
1116 )]
1117 pub surb_degraded_notify_period: Option<Duration>,
1118
1119 #[validate(custom(function = "validate_surb_idle_notify_period"))]
1130 #[default(default_session_surb_idle_notify_period())]
1131 #[cfg_attr(
1132 feature = "serde",
1133 serde(
1134 default = "default_session_surb_idle_notify_period",
1135 with = "humantime_serde::option"
1136 )
1137 )]
1138 pub surb_idle_notify_period: Option<Duration>,
1139
1140 #[default(default_session_surb_target_notify())]
1159 #[cfg_attr(feature = "serde", serde(default = "default_session_surb_target_notify"))]
1160 pub surb_target_notify: bool,
1161
1162 #[default(default_session_max_frames_behind_gap())]
1173 #[cfg_attr(feature = "serde", serde(default = "default_session_max_frames_behind_gap"))]
1174 pub max_frames_behind_gap: Option<usize>,
1175
1176 #[validate(custom(function = "validate_refusal_reply_budget"))]
1185 #[default(default_session_refusal_reply_budget())]
1186 #[cfg_attr(feature = "serde", serde(default = "default_session_refusal_reply_budget"))]
1187 pub refusal_reply_budget: Option<RefusalReplyBudget>,
1188
1189 #[validate(nested)]
1191 #[cfg_attr(feature = "serde", serde(default))]
1192 pub tag_allocator: hopr_transport_tag_allocator::TagAllocatorConfig,
1193}
1194
1195#[cfg(test)]
1196mod tests {
1197 use anyhow::Context;
1198 use hopr_protocol_pix::SHARE_EMISSION_WINDOW;
1199 use hopr_transport_session::{MAX_SSA_BATCH_SIZE, PIX_QUOTA_BYTES_PER_SHARE, SupervisorConfig};
1200
1201 use super::*;
1202
1203 #[test]
1214 fn default_pix_dimensions_must_be_inside_default_incoming_quota_range() {
1215 let pix = PixGlobalConfig::default();
1216 let incoming = IncomingSessionPixConfig::default();
1217
1218 let quota =
1219 pix.num_ssa_parts as u64 * (pix.ssa_part_size + pix.surplus_shares()) as u64 * PIX_QUOTA_BYTES_PER_SHARE;
1220
1221 assert!(
1222 incoming.quota_range.contains("a),
1223 "default PIX quota {quota} is outside the default accepted range {:?} — every PIX session would be \
1224 rejected with UnacceptablePixParams",
1225 incoming.quota_range
1226 );
1227
1228 assert_eq!(
1233 quota,
1234 *incoming.quota_range.end(),
1235 "the accepted range must be anchored at the nominal default quota"
1236 );
1237 }
1238
1239 #[test]
1240 fn relayer_health_weight_must_be_finite_and_non_negative() {
1241 for weight in [0.0, 1.0, 2.5] {
1242 let config = HoprProtocolConfig {
1243 relayer_health_weight: weight,
1244 ..Default::default()
1245 };
1246 assert!(config.validate().is_ok(), "a weight of {weight} must be accepted");
1247 }
1248 for weight in [-1.0, f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
1249 let config = HoprProtocolConfig {
1250 relayer_health_weight: weight,
1251 ..Default::default()
1252 };
1253 assert!(config.validate().is_err(), "a weight of {weight} must be rejected");
1254 }
1255 }
1256
1257 #[test]
1258 fn default_pix_configs_must_validate() {
1259 PixGlobalConfig::default()
1260 .validate()
1261 .expect("default PixGlobalConfig must be valid");
1262 validate_incoming_session_pix_config(&IncomingSessionPixConfig::default())
1263 .expect("default IncomingSessionPixConfig must be valid");
1264 HoprProtocolConfig::default()
1265 .validate()
1266 .expect("default HoprProtocolConfig must be valid");
1267 }
1268
1269 #[test]
1294 fn default_pix_emission_fits_one_deferral_bucket() {
1295 let cfg = HoprProtocolConfig::default();
1296
1297 let emitted_per_poly = cfg.pix.ssa_part_size + cfg.pix.surplus_shares();
1298 assert!(
1299 emitted_per_poly <= hopr_protocol_pix::MAX_DEFERRED_ACKS_PER_POLYNOMIAL,
1300 "default emission of {emitted_per_poly} shares per polynomial should fit one deferral bucket ({}), so \
1301 that no acknowledgement can be dropped for want of room",
1302 hopr_protocol_pix::MAX_DEFERRED_ACKS_PER_POLYNOMIAL
1303 );
1304
1305 assert!(
1308 cfg.incoming_session_pix_config.supervision.max_served_without_progress > 0,
1309 "the gate ceiling still bounds silence, and zero would disable it"
1310 );
1311
1312 let surplus_run = cfg.pix.surplus_shares() as u64 * cfg.pix.num_ssa_parts.min(SHARE_EMISSION_WINDOW) as u64;
1315 assert_eq!(
1316 40_448, surplus_run,
1317 "the shipped dimensions produce a 40 448-packet run of non-useful shares (79 x a window of 512; it was 20 \
1318 224 at a window of 256). This is a tripwire on the product of three values rather than an invariant: if \
1319 it moves, one of `PixGlobalConfig::ssa_part_size` (or the surplus: `additional_shares`, or the default \
1320 an unset one resolves to), `PixGlobalConfig::num_ssa_parts`, or \
1321 `hopr_protocol_pix::SHARE_EMISSION_WINDOW` has changed. Re-derive the run, then re-check that nothing \
1322 has started keying liveness on useful shares again"
1323 );
1324 }
1325
1326 #[test]
1336 fn pix_reconstructor_mirror_matches_the_protocol_defaults() {
1337 assert_eq!(
1338 SsaReconstructorConfig::default(),
1339 SsaReconstructorConfig::from(PixReconstructorConfig::default()),
1340 "the operator-facing mirror and the reconstructor it configures have drifted apart"
1341 );
1342 }
1343
1344 #[test]
1352 fn the_documented_ack_budget_floor_is_the_enforced_one() {
1353 const DOCUMENTED_FLOOR: usize = 25_600;
1354
1355 PixReconstructorConfig {
1356 max_ack_buffer_bytes: DOCUMENTED_FLOOR,
1357 ..Default::default()
1358 }
1359 .validate()
1360 .expect("the documented floor itself must be accepted");
1361
1362 assert!(
1363 PixReconstructorConfig {
1364 max_ack_buffer_bytes: DOCUMENTED_FLOOR - 1,
1365 ..Default::default()
1366 }
1367 .validate()
1368 .is_err(),
1369 "one byte below the documented floor must be rejected — the prose and the validator have drifted"
1370 );
1371 }
1372
1373 #[test]
1381 fn every_corner_of_the_pix_dimension_ranges_validates() -> anyhow::Result<()> {
1382 for num_ssa_parts in [8usize, 16192] {
1383 for ssa_part_size in [2usize, 255] {
1384 for additional_shares in [None, Some(0usize), Some(255)] {
1385 PixGlobalConfig {
1386 num_ssa_parts,
1387 ssa_part_size,
1388 additional_shares,
1389 ..Default::default()
1390 }
1391 .validate()
1392 .with_context(|| {
1393 format!("{num_ssa_parts} x ({ssa_part_size} + {additional_shares:?}) must be accepted")
1394 })?;
1395 }
1396 }
1397 }
1398 Ok(())
1399 }
1400
1401 #[test]
1404 fn the_assumed_session_rate_is_stated_in_packets() {
1405 assert_eq!(MAX_ASSUMED_SESSION_PACKET_RATE, 5000);
1406 }
1407
1408 #[test]
1413 fn default_recovery_deadline_must_cover_a_whole_cycle_at_the_accepted_quota() -> anyhow::Result<()> {
1414 let cfg = IncomingSessionPixConfig::default();
1415 validate_incoming_session_pix_config(&cfg).context("the shipping default must validate")?;
1416
1417 let without_fill = IncomingSessionPixConfig {
1418 supervision: SupervisorConfig {
1419 fill: hopr_transport_session::PixFillConfig {
1420 enabled: false,
1421 ..cfg.supervision.fill.clone()
1422 },
1423 ..cfg.supervision.clone()
1424 },
1425 ..cfg
1426 };
1427 validate_incoming_session_pix_config(&without_fill)
1428 .context("the shipping deadline must also clear the fill-off floor")?;
1429 Ok(())
1430 }
1431
1432 #[test]
1435 fn without_fill_a_deadline_below_one_cycle_at_the_assumed_rate_is_rejected() -> anyhow::Result<()> {
1436 let with_deadline = |max_recovery_time: Duration| IncomingSessionPixConfig {
1437 supervision: SupervisorConfig {
1438 max_recovery_time,
1439 fill: hopr_transport_session::PixFillConfig {
1440 enabled: false,
1441 ..Default::default()
1442 },
1443 ..Default::default()
1444 },
1445 ..Default::default()
1446 };
1447 let packets = *IncomingSessionPixConfig::default().quota_range.end() / PIX_QUOTA_BYTES_PER_SHARE;
1448 let needed = Duration::from_secs(packets.div_ceil(MAX_ASSUMED_SESSION_PACKET_RATE));
1449
1450 validate_incoming_session_pix_config(&with_deadline(needed))
1451 .context("a deadline of exactly one cycle at the assumed rate must be accepted")?;
1452 assert!(
1453 validate_incoming_session_pix_config(&with_deadline(needed - Duration::from_nanos(1))).is_err(),
1454 "a deadline a nanosecond short of {needed:?} must be refused"
1455 );
1456 Ok(())
1457 }
1458
1459 fn default_fill_rate_needed_within(max_recovery_time: Duration) -> u64 {
1462 let packets = *IncomingSessionPixConfig::default().quota_range.end() / PIX_QUOTA_BYTES_PER_SHARE;
1463 let fill = hopr_transport_session::PixFillConfig::default();
1464 let horizon = max_recovery_time.mul_f64(fill.finish_fraction);
1465 (packets as f64 * (1.0 + fill.loss_margin) / horizon.as_secs_f64()).ceil() as u64
1466 }
1467
1468 fn default_fill_off_floor() -> Duration {
1470 let packets = *IncomingSessionPixConfig::default().quota_range.end() / PIX_QUOTA_BYTES_PER_SHARE;
1471 Duration::from_secs(packets.div_ceil(MAX_ASSUMED_SESSION_PACKET_RATE))
1472 }
1473
1474 #[test]
1477 fn with_fill_the_deadline_is_judged_at_the_fill_ceiling() -> anyhow::Result<()> {
1478 let max_recovery_time = default_fill_off_floor() * 4;
1479 let needed_rate = default_fill_rate_needed_within(max_recovery_time);
1480 assert!(
1481 needed_rate <= MAX_ASSUMED_SESSION_PACKET_RATE,
1482 "test case must need no more than the assumed Session rate, needs {needed_rate}"
1483 );
1484
1485 let with_ceiling = |max_rate: u64| -> anyhow::Result<IncomingSessionPixConfig> {
1486 Ok(IncomingSessionPixConfig {
1487 supervision: SupervisorConfig {
1488 max_recovery_time,
1489 fill: hopr_transport_session::PixFillConfig {
1490 max_rate: u32::try_from(max_rate)?,
1491 ..Default::default()
1492 },
1493 ..Default::default()
1494 },
1495 ..Default::default()
1496 })
1497 };
1498
1499 validate_incoming_session_pix_config(&with_ceiling(needed_rate)?)
1500 .context("a ceiling that finishes the cycle in time must be accepted")?;
1501 assert!(
1502 validate_incoming_session_pix_config(&with_ceiling(needed_rate - 1)?).is_err(),
1503 "a ceiling one packet/s short of {needed_rate} must be refused"
1504 );
1505 Ok(())
1506 }
1507
1508 #[test]
1511 fn a_fill_ceiling_above_the_assumed_session_rate_buys_no_shorter_deadline() -> anyhow::Result<()> {
1512 const LARGEST_LEGAL_FILL_RATE: u32 = 10_000;
1514 let with_deadline = |max_recovery_time: Duration| IncomingSessionPixConfig {
1515 supervision: SupervisorConfig {
1516 max_recovery_time,
1517 fill: hopr_transport_session::PixFillConfig {
1518 max_rate: LARGEST_LEGAL_FILL_RATE,
1519 ..Default::default()
1520 },
1521 ..Default::default()
1522 },
1523 ..Default::default()
1524 };
1525
1526 let too_short = default_fill_off_floor();
1527 let needed_rate = default_fill_rate_needed_within(too_short);
1528 assert!(
1529 needed_rate > MAX_ASSUMED_SESSION_PACKET_RATE && needed_rate <= u64::from(LARGEST_LEGAL_FILL_RATE),
1530 "test case must need more than the assumed Session rate but no more than the ceiling, needs {needed_rate}"
1531 );
1532 assert!(
1533 validate_incoming_session_pix_config(&with_deadline(too_short)).is_err(),
1534 "a deadline that needs {needed_rate} packets/s of fill must be refused despite the ceiling allowing it"
1535 );
1536
1537 let long_enough = too_short * 2;
1538 assert!(
1539 default_fill_rate_needed_within(long_enough) <= MAX_ASSUMED_SESSION_PACKET_RATE,
1540 "test case must need no more than the assumed Session rate"
1541 );
1542 validate_incoming_session_pix_config(&with_deadline(long_enough))
1543 .context("a deadline within the assumed Session rate must be accepted")?;
1544 Ok(())
1545 }
1546
1547 #[test]
1559 fn a_fill_ceiling_below_the_widest_accepted_quota_is_rejected() {
1560 let cfg = IncomingSessionPixConfig::default();
1561 let packets = *cfg.quota_range.end() / PIX_QUOTA_BYTES_PER_SHARE;
1562 let horizon = cfg
1563 .supervision
1564 .max_recovery_time
1565 .mul_f64(cfg.supervision.fill.finish_fraction);
1566 let floor = (packets as f64 * (1.0 + cfg.supervision.fill.loss_margin) / horizon.as_secs_f64()).ceil() as u32;
1567
1568 assert!(
1569 cfg.supervision.fill.max_rate >= floor,
1570 "the shipping default ceiling ({}) must clear the {floor} packets/s its own quota range needs",
1571 cfg.supervision.fill.max_rate
1572 );
1573 validate_incoming_session_pix_config(&cfg).expect("the shipping default must validate");
1574
1575 let starved = IncomingSessionPixConfig {
1576 supervision: SupervisorConfig {
1577 fill: hopr_transport_session::PixFillConfig {
1578 max_rate: floor - 1,
1579 ..Default::default()
1580 },
1581 ..Default::default()
1582 },
1583 ..Default::default()
1584 };
1585 assert!(
1586 validate_incoming_session_pix_config(&starved).is_err(),
1587 "a ceiling one packet/s short of the requirement must be refused"
1588 );
1589
1590 let disabled = IncomingSessionPixConfig {
1593 supervision: SupervisorConfig {
1594 fill: hopr_transport_session::PixFillConfig {
1595 enabled: false,
1596 max_rate: 1,
1597 ..Default::default()
1598 },
1599 ..Default::default()
1600 },
1601 ..Default::default()
1602 };
1603 validate_incoming_session_pix_config(&disabled)
1604 .expect("a disabled filler must not be judged against a rate it will never use");
1605 }
1606
1607 #[test]
1615 fn a_live_cycle_budget_too_small_for_the_accepted_quota_is_rejected() {
1616 let cfg = IncomingSessionPixConfig::default();
1617 let widest = hopr_transport_session::max_cycle_budget_for_quota(
1618 *cfg.quota_range.end(),
1619 cfg.supervision.ssas_per_request,
1620 );
1621
1622 assert!(
1623 cfg.max_live_cycle_bytes >= widest,
1624 "the shipping default budget ({}) must admit one session at the top of its own quota range ({widest})",
1625 cfg.max_live_cycle_bytes
1626 );
1627 validate_incoming_session_pix_config(&cfg).expect("the shipping default must validate");
1628
1629 let starved = IncomingSessionPixConfig {
1630 max_live_cycle_bytes: widest - 1,
1631 ..Default::default()
1632 };
1633 assert!(
1634 validate_incoming_session_pix_config(&starved).is_err(),
1635 "a budget one byte short of a single session must be refused"
1636 );
1637
1638 let batched = IncomingSessionPixConfig {
1649 max_live_cycle_bytes: widest,
1650 supervision: SupervisorConfig {
1651 ssas_per_request: hopr_transport_session::MAX_SSA_BATCH_SIZE,
1652 ..cfg.supervision.clone()
1653 },
1654 ..cfg.clone()
1655 };
1656 assert!(
1657 validate_incoming_session_pix_config(&batched).is_err(),
1658 "a batch of {} live cycles per session needs a budget raised past the {widest} one cycle needs",
1659 hopr_transport_session::MAX_SSA_BATCH_SIZE
1660 );
1661 }
1662
1663 #[allow(clippy::reversed_empty_ranges)]
1667 #[test]
1668 fn empty_pix_quota_range_is_rejected() {
1669 let cfg = IncomingSessionPixConfig {
1670 quota_range: 100..=10,
1671 ..Default::default()
1672 };
1673 assert!(validate_incoming_session_pix_config(&cfg).is_err());
1674
1675 let cfg = HoprProtocolConfig {
1676 incoming_session_pix_config: IncomingSessionPixConfig {
1677 quota_range: 100..=10,
1678 ..Default::default()
1679 },
1680 ..Default::default()
1681 };
1682 assert!(cfg.validate().is_err());
1683 }
1684
1685 #[cfg(feature = "serde")]
1688 #[test]
1689 fn surb_target_notify_is_configurable_and_on_by_default() -> anyhow::Result<()> {
1690 assert!(SessionGlobalConfig::default().surb_target_notify);
1691
1692 let omitted: SessionGlobalConfig =
1693 serde_saphyr::from_str("idle_timeout: 3m\n").context("config without the setting must parse")?;
1694 assert!(
1695 omitted.surb_target_notify,
1696 "a configuration that does not name the setting must announce the target, as it always did"
1697 );
1698
1699 let off: SessionGlobalConfig =
1700 serde_saphyr::from_str("surb_target_notify: false\n").context("config turning it off must parse")?;
1701 assert!(!off.surb_target_notify);
1702
1703 let on: SessionGlobalConfig =
1704 serde_saphyr::from_str("surb_target_notify: true\n").context("config turning it on must parse")?;
1705 assert!(on.surb_target_notify);
1706 Ok(())
1707 }
1708
1709 #[cfg(feature = "serde")]
1710 #[test]
1711 fn path_planner_weights_are_reachable_from_serialized_config() {
1712 let json = r#"{
1713 "path_planner": {
1714 "latency_halflife": "250ms",
1715 "capacity_reference": 5000,
1716 "edge_penalty": 0.8,
1717 "return_path_weight_temper": 0.25
1718 }
1719 }"#;
1720 let cfg: HoprProtocolConfig = serde_json::from_str(json).expect("path planner weights must deserialize");
1721 let planner = cfg.path_planner;
1722 let defaults = crate::path::PathPlannerConfig::default();
1723
1724 assert_eq!(Duration::from_millis(250), planner.latency_halflife);
1725 assert_eq!(5000, planner.capacity_reference);
1726 assert_eq!(0.8, planner.edge_penalty);
1727 assert_eq!(0.25, planner.return_path_weight_temper);
1728 assert_eq!(
1729 defaults.min_ack_rate, planner.min_ack_rate,
1730 "unspecified planner fields must keep their defaults"
1731 );
1732 assert_eq!(defaults.cache_ttl, planner.cache_ttl);
1733 assert!(cfg.validate().is_ok());
1734
1735 let bad_temper = r#"{ "path_planner": { "return_path_weight_temper": 1.5 } }"#;
1736 let cfg: HoprProtocolConfig = serde_json::from_str(bad_temper).expect("it parses; validation rejects it");
1737 assert!(cfg.validate().is_err(), "an out-of-range temper must fail validation");
1738
1739 let typo = r#"{ "path_planner": { "latency_halflif": "250ms" } }"#;
1740 assert!(
1741 serde_json::from_str::<HoprProtocolConfig>(typo).is_err(),
1742 "a misspelled planner key must be rejected, not silently ignored"
1743 );
1744
1745 let round_trip: HoprProtocolConfig =
1746 serde_json::from_str(&serde_json::to_string(&cfg).expect("serialize")).expect("round trip");
1747 assert_eq!(cfg, round_trip);
1748 }
1749
1750 #[cfg(feature = "serde")]
1751 #[test]
1752 fn pix_configs_are_reachable_from_serialized_config() {
1753 let json = r#"{
1758 "pix": { "num_ssa_parts": 2048 },
1759 "incoming_session_pix_config": {
1760 "enforce_pix": true,
1761 "supervision": { "max_deposit_wait": "90s" }
1762 }
1763 }"#;
1764 let cfg: HoprProtocolConfig = serde_json::from_str(json).expect("PIX config must deserialize");
1765
1766 assert_eq!(2048, cfg.pix.num_ssa_parts);
1767 assert_eq!(
1769 PixGlobalConfig::default().ssa_part_size,
1770 cfg.pix.ssa_part_size,
1771 "unspecified PIX fields must fall back to their defaults"
1772 );
1773 assert!(cfg.incoming_session_pix_config.enforce_pix);
1774 assert_eq!(
1775 Duration::from_secs(90),
1776 cfg.incoming_session_pix_config.supervision.max_deposit_wait
1777 );
1778 assert_eq!(
1779 hopr_transport_session::SupervisorConfig::default().max_recovery_time,
1780 cfg.incoming_session_pix_config.supervision.max_recovery_time,
1781 "unspecified supervision fields must fall back to their defaults"
1782 );
1783 assert!(
1784 cfg.incoming_session_pix_config.supervision.allow_dynamic_ssa_batches,
1785 "omitting allow_dynamic_ssa_batches must retain its true default"
1786 );
1787 assert_eq!(
1788 IncomingSessionPixConfig::default().quota_range,
1789 cfg.incoming_session_pix_config.quota_range
1790 );
1791
1792 assert_eq!(
1797 hopr_transport_session::PixFillConfig::default(),
1798 cfg.incoming_session_pix_config.supervision.fill,
1799 "a config that names no fill block must get the shipped one"
1800 );
1801 let json = r#"{
1802 "incoming_session_pix_config": {
1803 "supervision": { "fill": { "max_rate": 500 } }
1804 }
1805 }"#;
1806 let cfg: HoprProtocolConfig = serde_json::from_str(json).expect("a partial fill block must deserialize");
1807 let fill = &cfg.incoming_session_pix_config.supervision.fill;
1808 assert_eq!(500, fill.max_rate);
1809 assert_eq!(
1810 hopr_transport_session::PixFillConfig::default().heartbeat,
1811 fill.heartbeat,
1812 "unspecified fill fields must fall back to their defaults"
1813 );
1814 assert!(fill.enabled, "omitting `enabled` must retain its true default");
1815
1816 let json = r#"{
1820 "pix": { "max_ssas_per_request": 5 },
1821 "incoming_session_pix_config": {
1822 "supervision": {
1823 "ssas_per_request": 5,
1824 "allow_dynamic_ssa_batches": false
1825 }
1826 }
1827 }"#;
1828 let cfg: HoprProtocolConfig = serde_json::from_str(json).expect("SSA batch config must deserialize");
1829 assert_eq!(5, cfg.pix.max_ssas_per_request);
1830 assert_eq!(5, cfg.incoming_session_pix_config.supervision.ssas_per_request);
1831 assert!(!cfg.incoming_session_pix_config.supervision.allow_dynamic_ssa_batches);
1832 cfg.validate().expect("a matched pair of batch knobs must validate");
1833
1834 let json = r#"{
1844 "pix": { "reconstructor": { "max_ack_await_time": "45s", "max_tracked_peers": 500 } },
1845 "incoming_session_pix_config": { "supervision": { "tombstone_retention_window": "60s" } }
1846 }"#;
1847 let cfg: HoprProtocolConfig = serde_json::from_str(json).expect("reconstructor config must deserialize");
1848 assert_eq!(Duration::from_secs(45), cfg.pix.reconstructor.max_ack_await_time);
1849 assert_eq!(500, cfg.pix.reconstructor.max_tracked_peers);
1850 assert_eq!(
1851 PixReconstructorConfig::default().unused_verifier_lifetime,
1852 cfg.pix.reconstructor.unused_verifier_lifetime,
1853 "unspecified reconstructor fields must fall back to their defaults"
1854 );
1855 cfg.validate().expect("a narrowed reconstructor must validate");
1856
1857 let unpaired = r#"{ "pix": { "reconstructor": { "max_ack_await_time": "45s" } } }"#;
1860 let unpaired: HoprProtocolConfig = serde_json::from_str(unpaired).expect("must deserialize");
1861 assert!(
1862 unpaired.validate().is_err(),
1863 "a 45 s ack window against the default 30 s tombstone must be rejected, not silently accepted against the \
1864 reconstructor defaults the node no longer uses"
1865 );
1866
1867 assert_eq!(
1870 Duration::from_secs(45),
1871 SsaReconstructorConfig::from(cfg.pix.reconstructor).max_ack_await_time
1872 );
1873
1874 let json = r#"{ "pix": { "ssa_part_size": 48 } }"#;
1880 let cfg: HoprProtocolConfig = serde_json::from_str(json).expect("PIX dimensions must deserialize");
1881 assert_eq!(None, cfg.pix.additional_shares, "the field itself stays unset");
1882 assert_eq!(
1883 103,
1884 cfg.pix.surplus_shares(),
1885 "and resolves to the derivation at 4096 x 48"
1886 );
1887
1888 let json = r#"{ "pix": { "ssa_part_size": 32, "additional_shares": 30 } }"#;
1889 let cfg: HoprProtocolConfig = serde_json::from_str(json).expect("an explicit surplus must deserialize");
1890 assert_eq!(30, cfg.pix.surplus_shares(), "an explicit surplus is passed through");
1891
1892 let json = r#"{ "pix": { "ssa_part_size": 16, "additional_shares": 65 } }"#;
1896 let cfg: HoprProtocolConfig = serde_json::from_str(json).expect("it parses; validation is what rejects it");
1897 assert!(
1898 cfg.validate().is_ok(),
1899 "a surplus above the threshold must be accepted — only the wire byte bounds it"
1900 );
1901 }
1902
1903 #[test]
1915 fn the_surplus_is_bounded_only_by_the_wire_byte() {
1916 for (ssa_part_size, additional_shares) in [(32usize, 81usize), (16, 54), (64, 128), (64, 255)] {
1921 let cfg = PixGlobalConfig {
1922 ssa_part_size,
1923 additional_shares: Some(additional_shares),
1924 ..Default::default()
1925 };
1926 cfg.validate().unwrap_or_else(|e| {
1927 panic!("threshold {ssa_part_size} with surplus {additional_shares} must be admissible: {e}")
1928 });
1929 }
1930
1931 let past_the_wire_byte = PixGlobalConfig {
1934 ssa_part_size: 64,
1935 additional_shares: Some(256),
1936 ..Default::default()
1937 };
1938 let errors = past_the_wire_byte
1939 .validate()
1940 .expect_err("a surplus that cannot fit the PixParams byte must be rejected");
1941 assert!(
1942 errors.field_errors().contains_key("additional_shares"),
1943 "the field range must fire through the Option, not only a schema check"
1944 );
1945 }
1946
1947 #[test]
1955 fn the_derived_surplus_follows_the_configured_split() {
1956 for ssa_part_size in 2usize..=255 {
1957 let cfg = PixGlobalConfig {
1958 num_ssa_parts: 8,
1959 ssa_part_size,
1960 ..Default::default()
1961 };
1962 let surplus = cfg.surplus_shares();
1963 assert_eq!(
1964 hopr_protocol_pix::default_surplus_for(8, ssa_part_size as u8) as usize,
1965 surplus
1966 );
1967 assert!(
1968 surplus > 0,
1969 "ssa_part_size {ssa_part_size} derives no surplus, i.e. no loss tolerance at all"
1970 );
1971 assert!(
1972 cfg.validate().is_ok(),
1973 "a derived surplus must never fail the bound it is derived under"
1974 );
1975 }
1976
1977 let at = |num_ssa_parts: usize, ssa_part_size: usize| {
1980 PixGlobalConfig {
1981 num_ssa_parts,
1982 ssa_part_size,
1983 ..Default::default()
1984 }
1985 .surplus_shares()
1986 };
1987 let polys = DEFAULT_PIX_POLYS_PER_SSA as usize;
1988 for ssa_part_size in 3usize..=255 {
1989 assert!(
1990 at(polys, ssa_part_size) >= at(polys, ssa_part_size - 1),
1991 "the derived surplus falls from ssa_part_size {} to {ssa_part_size}",
1992 ssa_part_size - 1
1993 );
1994 }
1995
1996 assert!(at(8192, 32) > at(4096, 32), "the surplus must grow with num_ssa_parts");
1999
2000 assert_eq!(
2002 hopr_protocol_pix::DEFAULT_SURPLUS_SHARES as usize,
2003 PixGlobalConfig::default().surplus_shares(),
2004 "the deployed split must derive the deployed surplus"
2005 );
2006 }
2007
2008 #[test]
2015 fn ssa_batch_knobs_are_bounded_by_the_shared_ceiling() {
2016 let at_ceiling = PixGlobalConfig {
2018 max_ssas_per_request: MAX_SSA_BATCH_SIZE,
2019 ..Default::default()
2020 };
2021 assert!(
2022 at_ceiling.validate().is_ok(),
2023 "MAX_SSA_BATCH_SIZE itself must be accepted — the range literal has drifted below it"
2024 );
2025 let past_ceiling = PixGlobalConfig {
2026 max_ssas_per_request: MAX_SSA_BATCH_SIZE + 1,
2027 ..Default::default()
2028 };
2029 assert!(
2030 past_ceiling.validate().is_err(),
2031 "above MAX_SSA_BATCH_SIZE must be rejected — the range literal has drifted above it"
2032 );
2033
2034 assert!(
2035 PixGlobalConfig {
2036 max_ssas_per_request: 0,
2037 ..Default::default()
2038 }
2039 .validate()
2040 .is_err(),
2041 "an Entry accepting zero SSAs per request would reject every request"
2042 );
2043
2044 let with_supervision = |supervision: SupervisorConfig| HoprProtocolConfig {
2054 incoming_session_pix_config: IncomingSessionPixConfig {
2055 max_live_cycle_bytes: u64::MAX,
2056 supervision,
2057 ..Default::default()
2058 },
2059 ..Default::default()
2060 };
2061
2062 for ssas_per_request in [0, MAX_SSA_BATCH_SIZE + 1] {
2063 assert!(
2064 with_supervision(SupervisorConfig {
2065 ssas_per_request,
2066 ..Default::default()
2067 })
2068 .validate()
2069 .is_err(),
2070 "ssas_per_request of {ssas_per_request} is outside 1..={MAX_SSA_BATCH_SIZE} and must be rejected"
2071 );
2072 }
2073
2074 assert!(
2075 with_supervision(SupervisorConfig {
2076 ssas_per_request: MAX_SSA_BATCH_SIZE,
2077 ..Default::default()
2078 })
2079 .validate()
2080 .is_ok(),
2081 "the ceiling itself must be accepted"
2082 );
2083
2084 const SUPERVISOR_DURATION_CAP: Duration = Duration::from_secs(24 * 3600);
2092 let per_cycle = SUPERVISOR_DURATION_CAP / MAX_SSA_BATCH_SIZE as u32 + Duration::from_secs(1);
2093 assert!(
2094 with_supervision(SupervisorConfig {
2095 ssas_per_request: MAX_SSA_BATCH_SIZE,
2096 max_deposit_wait: per_cycle,
2097 ..Default::default()
2098 })
2099 .validate()
2100 .is_err(),
2101 "{MAX_SSA_BATCH_SIZE} x {per_cycle:?} of deposit wait exceeds the supervisor duration cap and must be \
2102 rejected"
2103 );
2104 }
2105
2106 #[test]
2119 fn supervision_is_validated_against_the_configured_reconstructor_not_the_default() {
2120 let shortened = HoprProtocolConfig {
2121 pix: PixGlobalConfig {
2122 reconstructor: PixReconstructorConfig {
2123 unused_verifier_lifetime: Duration::from_secs(30),
2124 ..Default::default()
2125 },
2126 ..Default::default()
2127 },
2128 ..Default::default()
2129 };
2130
2131 assert!(
2132 shortened.pix.validate().is_ok(),
2133 "the shortened lifetime is valid on its own — the conflict is with its sibling"
2134 );
2135 assert!(
2136 validate_incoming_session_pix_config(&shortened.incoming_session_pix_config).is_ok(),
2137 "and the supervisor is valid on its own too, which is why neither field validator catches this"
2138 );
2139 assert!(
2140 shortened.validate().is_err(),
2141 "a 30 s verifier lifetime cannot support the default 60 s max_recovery_idle, and only the parent-level \
2142 check can see both"
2143 );
2144
2145 assert!(
2146 HoprProtocolConfig::default().validate().is_ok(),
2147 "the shipping defaults must still pair"
2148 );
2149 }
2150
2151 #[test]
2152 fn egress_backpressure_timeout_rejects_sub_minimum_values() {
2153 assert!(validate_egress_backpressure_timeout(&Duration::ZERO).is_err());
2154 assert!(validate_egress_backpressure_timeout(&Duration::from_micros(500)).is_err());
2155 assert!(validate_egress_backpressure_timeout(&MIN_EGRESS_BACKPRESSURE_TIMEOUT).is_ok());
2156 assert!(validate_egress_backpressure_timeout(&DEFAULT_EGRESS_BACKPRESSURE_TIMEOUT).is_ok());
2157 }
2158
2159 #[test]
2160 fn stream_protocol_config_default_is_valid() {
2161 assert!(StreamProtocolConfig::default().validate().is_ok());
2162 }
2163
2164 #[test]
2165 fn test_valid_domains_for_looks_like_a_domain() {
2166 assert!(looks_like_domain("localhost"));
2167 assert!(looks_like_domain("hoprnet.org"));
2168 assert!(looks_like_domain("hub.hoprnet.org"));
2169 }
2170
2171 #[test]
2172 fn test_valid_domains_for_does_not_look_like_a_domain() {
2173 assert!(!looks_like_domain(".org"));
2174 assert!(!looks_like_domain("-hoprnet-.org"));
2175 }
2176
2177 #[test]
2178 fn test_valid_domains_should_be_reachable() {
2179 assert!(!is_reachable_domain("google.com"));
2180 }
2181
2182 #[test]
2183 fn test_verify_valid_ip4_addresses() {
2184 assert!(validate_ipv4_address("1.1.1.1").is_ok());
2185 assert!(validate_ipv4_address("1.255.1.1").is_ok());
2186 assert!(validate_ipv4_address("187.1.1.255").is_ok());
2187 assert!(validate_ipv4_address("127.0.0.1").is_ok());
2188 }
2189
2190 #[test]
2191 fn test_verify_invalid_ip4_addresses() {
2192 assert!(validate_ipv4_address("1.256.1.1").is_err());
2193 assert!(validate_ipv4_address("-1.1.1.255").is_err());
2194 assert!(validate_ipv4_address("127.0.0.256").is_err());
2195 assert!(validate_ipv4_address("1").is_err());
2196 assert!(validate_ipv4_address("1.1").is_err());
2197 assert!(validate_ipv4_address("1.1.1").is_err());
2198 assert!(validate_ipv4_address("1.1.1.1.1").is_err());
2199 }
2200
2201 #[test]
2202 fn test_verify_valid_dns_addresses() {
2203 assert!(validate_dns_address("localhost").is_ok());
2204 assert!(validate_dns_address("google.com").is_ok());
2205 assert!(validate_dns_address("hub.hoprnet.org").is_ok());
2206 }
2207
2208 #[test]
2209 fn test_verify_invalid_dns_addresses() {
2210 assert!(validate_dns_address("-hoprnet-.org").is_err());
2211 }
2212
2213 #[test]
2214 fn test_multiaddress_on_dappnode_default() {
2215 temp_env::with_var("DAPPNODE", Some("true"), || {
2216 assert_eq!(default_multiaddr_transport(1234), "tcp/1234");
2217 });
2218 }
2219
2220 #[cfg(feature = "p2p-announce-quic")]
2221 #[test]
2222 fn test_multiaddress_on_non_dappnode_default() {
2223 temp_env::with_vars([("DAPPNODE", Some("false")), ("HOPRD_NAT", Some("false"))], || {
2224 assert_eq!(default_multiaddr_transport(1234), "udp/1234/quic-v1");
2225 });
2226 }
2227
2228 #[cfg(not(feature = "p2p-announce-quic"))]
2229 #[test]
2230 fn test_multiaddress_on_non_dappnode_default() {
2231 assert_eq!(default_multiaddr_transport(1234), "tcp/1234");
2232 }
2233
2234 #[test]
2235 fn test_multiaddress_on_non_dappnode_uses_nat() {
2236 temp_env::with_var("HOPRD_NAT", Some("true"), || {
2237 assert_eq!(default_multiaddr_transport(1234), "tcp/1234");
2238 });
2239 }
2240
2241 #[cfg(feature = "p2p-announce-quic")]
2242 #[test]
2243 fn test_multiaddress_on_non_dappnode_not_uses_nat() {
2244 temp_env::with_var("HOPRD_NAT", Some("false"), || {
2245 assert_eq!(default_multiaddr_transport(1234), "udp/1234/quic-v1");
2246 });
2247 }
2248
2249 #[cfg(not(feature = "p2p-announce-quic"))]
2250 #[test]
2251 fn test_multiaddress_on_non_dappnode_not_uses_nat() {
2252 temp_env::with_var("HOPRD_NAT", Some("false"), || {
2253 assert_eq!(default_multiaddr_transport(1234), "tcp/1234");
2254 });
2255 }
2256
2257 #[cfg(feature = "p2p-announce-quic")]
2258 #[test]
2259 fn test_multiaddress_on_dappnode_not_uses_nat() {
2260 temp_env::with_vars([("DAPPNODE", Some("true")), ("HOPRD_NAT", Some("false"))], || {
2261 assert_eq!(default_multiaddr_transport(1234), "udp/1234/quic-v1");
2262 });
2263 }
2264
2265 #[cfg(not(feature = "p2p-announce-quic"))]
2266 #[test]
2267 fn test_multiaddress_on_dappnode_not_uses_nat() {
2268 temp_env::with_vars([("DAPPNODE", Some("true")), ("HOPRD_NAT", Some("false"))], || {
2269 assert_eq!(default_multiaddr_transport(1234), "tcp/1234");
2270 });
2271 }
2272
2273 #[test]
2276 fn host_config_parses_ipv4_address() {
2277 let cfg = HostConfig::from_str("1.2.3.4:9091").unwrap();
2278 insta::assert_debug_snapshot!(cfg);
2279 }
2280
2281 #[test]
2282 fn host_config_parses_domain() {
2283 let cfg = HostConfig::from_str("example.com:443").unwrap();
2284 insta::assert_debug_snapshot!(cfg);
2285 }
2286
2287 #[test]
2288 fn host_config_rejects_missing_port() {
2289 assert!(HostConfig::from_str("1.2.3.4").is_err());
2290 }
2291
2292 #[test]
2293 fn host_config_rejects_invalid_port() {
2294 assert!(HostConfig::from_str("1.2.3.4:abc").is_err());
2295 }
2296
2297 #[test]
2298 fn host_config_rejects_invalid_host() {
2299 assert!(HostConfig::from_str("-invalid-.com:80").is_err());
2300 }
2301
2302 #[test]
2303 fn host_config_display_roundtrip() {
2304 let cfg = HostConfig {
2305 address: HostType::IPv4("10.0.0.1".into()),
2306 port: 8080,
2307 };
2308 insta::assert_yaml_snapshot!(cfg.to_string());
2309 }
2310
2311 #[test]
2314 fn multiaddr_from_ipv4_host_config() {
2315 let cfg = HostConfig {
2316 address: HostType::IPv4("1.2.3.4".into()),
2317 port: 9091,
2318 };
2319 let addr = Multiaddr::try_from(&cfg).unwrap();
2320 insta::assert_yaml_snapshot!(addr.to_string());
2321 }
2322
2323 #[test]
2324 fn multiaddr_from_domain_host_config() {
2325 let cfg = HostConfig {
2326 address: HostType::Domain("example.com".into()),
2327 port: 443,
2328 };
2329 let addr = Multiaddr::try_from(&cfg).unwrap();
2330 insta::assert_yaml_snapshot!(addr.to_string());
2331 }
2332
2333 #[test]
2336 fn session_global_config_default_is_valid() {
2337 let cfg = SessionGlobalConfig::default();
2338 assert!(cfg.validate().is_ok());
2339 }
2340
2341 #[test]
2342 fn session_global_config_too_low_idle_timeout_is_rejected() {
2343 let cfg = SessionGlobalConfig {
2344 idle_timeout: Duration::from_millis(100),
2345 ..Default::default()
2346 };
2347 assert!(cfg.validate().is_err());
2348 }
2349
2350 #[test]
2351 fn session_global_config_too_many_retries_is_rejected() {
2352 let cfg = SessionGlobalConfig {
2353 establish_max_retries: 21,
2354 ..Default::default()
2355 };
2356 assert!(cfg.validate().is_err());
2357 }
2358
2359 #[test]
2362 fn surb_degraded_notify_period_defaults_to_one_second() {
2363 let cfg = SessionGlobalConfig::default();
2364 assert_eq!(
2365 Some(Duration::from_secs(1)),
2366 cfg.surb_degraded_notify_period,
2367 "the fast cadence must be on by default, or a dark forward path keeps the 15 s wait"
2368 );
2369 assert!(
2371 cfg.surb_degraded_notify_period < cfg.surb_balance_notify_period,
2372 "the degraded period must report faster than the normal one"
2373 );
2374 }
2375
2376 #[cfg(feature = "serde")]
2377 #[test]
2378 fn surb_degraded_notify_period_null_disables_it() -> anyhow::Result<()> {
2379 let cfg: SessionGlobalConfig =
2380 serde_saphyr::from_str("surb_degraded_notify_period: null").context("null must parse")?;
2381 assert_eq!(None, cfg.surb_degraded_notify_period);
2382 assert!(cfg.validate().is_ok(), "disabling the degraded period is valid");
2383 Ok(())
2384 }
2385
2386 #[test]
2387 fn surb_degraded_notify_period_below_the_floor_is_rejected() {
2388 let cfg = SessionGlobalConfig {
2389 surb_degraded_notify_period: Some(Duration::from_millis(999)),
2390 ..Default::default()
2391 };
2392 assert!(
2393 cfg.validate().is_err(),
2394 "the same 1 s floor as the normal period applies"
2395 );
2396
2397 let at_floor = SessionGlobalConfig {
2398 surb_degraded_notify_period: Some(Duration::from_secs(1)),
2399 ..Default::default()
2400 };
2401 assert!(at_floor.validate().is_ok());
2402 }
2403
2404 #[cfg(feature = "serde")]
2405 #[test]
2406 fn surb_degraded_notify_period_parses_humantime() -> anyhow::Result<()> {
2407 let cfg: SessionGlobalConfig =
2408 serde_saphyr::from_str("surb_degraded_notify_period: 2s").context("a humantime period must parse")?;
2409 assert_eq!(Some(Duration::from_secs(2)), cfg.surb_degraded_notify_period);
2410 Ok(())
2411 }
2412
2413 #[test]
2416 fn surb_idle_notify_period_defaults_to_45_seconds() {
2417 let cfg = SessionGlobalConfig::default();
2418 assert_eq!(Some(Duration::from_secs(45)), cfg.surb_idle_notify_period);
2419 assert!(
2420 cfg.surb_idle_notify_period <= Some(cfg.idle_timeout / 4),
2421 "the default must not trigger the clamp warning"
2422 );
2423 assert!(
2424 cfg.surb_idle_notify_period > cfg.surb_balance_notify_period,
2425 "the idle period must report slower than the normal one, or it backs nothing off"
2426 );
2427 assert!(cfg.validate().is_ok());
2428 }
2429
2430 #[cfg(feature = "serde")]
2431 #[test]
2432 fn surb_idle_notify_period_null_disables_it() -> anyhow::Result<()> {
2433 let cfg: SessionGlobalConfig =
2434 serde_saphyr::from_str("surb_idle_notify_period: null").context("null must parse")?;
2435 assert_eq!(None, cfg.surb_idle_notify_period);
2436 assert!(cfg.validate().is_ok(), "disabling the idle backoff is valid");
2437 Ok(())
2438 }
2439
2440 #[test]
2441 fn surb_idle_notify_period_below_the_floor_is_rejected() {
2442 let cfg = SessionGlobalConfig {
2443 surb_idle_notify_period: Some(Duration::from_millis(999)),
2444 ..Default::default()
2445 };
2446 assert!(cfg.validate().is_err());
2447
2448 let at_floor = SessionGlobalConfig {
2449 surb_idle_notify_period: Some(Duration::from_secs(1)),
2450 ..Default::default()
2451 };
2452 assert!(at_floor.validate().is_ok());
2453 }
2454
2455 #[cfg(feature = "serde")]
2456 #[test]
2457 fn surb_idle_notify_period_parses_humantime() -> anyhow::Result<()> {
2458 let cfg: SessionGlobalConfig =
2459 serde_saphyr::from_str("surb_idle_notify_period: 45s").context("a humantime period must parse")?;
2460 assert_eq!(Some(Duration::from_secs(45)), cfg.surb_idle_notify_period);
2461 Ok(())
2462 }
2463
2464 #[test]
2467 fn refusal_reply_budget_defaults_to_a_burst_of_32_and_one_reply_a_second() {
2468 let cfg = SessionGlobalConfig::default();
2469 assert_eq!(
2470 Some(RefusalReplyBudget {
2471 burst: 32,
2472 refill_period: Duration::from_secs(1),
2473 }),
2474 cfg.refusal_reply_budget
2475 );
2476 assert!(cfg.validate().is_ok());
2477 }
2478
2479 #[cfg(feature = "serde")]
2480 #[test]
2481 fn refusal_reply_budget_defaults_when_omitted_from_the_config_file() -> anyhow::Result<()> {
2482 let cfg: SessionGlobalConfig = serde_saphyr::from_str("idle_timeout: 3m").context("must parse")?;
2483 assert_eq!(
2484 SessionGlobalConfig::default().refusal_reply_budget,
2485 cfg.refusal_reply_budget
2486 );
2487 Ok(())
2488 }
2489
2490 #[cfg(feature = "serde")]
2491 #[test]
2492 fn refusal_reply_budget_null_means_unlimited() -> anyhow::Result<()> {
2493 let cfg: SessionGlobalConfig =
2494 serde_saphyr::from_str("refusal_reply_budget: null").context("null must parse")?;
2495 assert_eq!(None, cfg.refusal_reply_budget);
2496 assert!(cfg.validate().is_ok(), "an unbounded budget is valid");
2497 Ok(())
2498 }
2499
2500 #[cfg(feature = "serde")]
2501 #[test]
2502 fn refusal_reply_budget_parses_humantime() -> anyhow::Result<()> {
2503 let cfg: SessionGlobalConfig =
2504 serde_saphyr::from_str("refusal_reply_budget: { burst: 5, refill_period: 250ms }")
2505 .context("a humantime refill period must parse")?;
2506 assert_eq!(
2507 Some(RefusalReplyBudget {
2508 burst: 5,
2509 refill_period: Duration::from_millis(250),
2510 }),
2511 cfg.refusal_reply_budget
2512 );
2513 Ok(())
2514 }
2515
2516 #[test]
2517 fn refusal_reply_budget_with_a_zero_refill_period_is_rejected() {
2518 let cfg = SessionGlobalConfig {
2519 refusal_reply_budget: Some(RefusalReplyBudget {
2520 burst: 1,
2521 refill_period: Duration::ZERO,
2522 }),
2523 ..Default::default()
2524 };
2525 assert!(cfg.validate().is_err());
2526
2527 let at_floor = SessionGlobalConfig {
2528 refusal_reply_budget: Some(RefusalReplyBudget {
2529 burst: 0,
2530 refill_period: MIN_REFUSAL_REPLY_REFILL_PERIOD,
2531 }),
2532 ..Default::default()
2533 };
2534 assert!(
2535 at_floor.validate().is_ok(),
2536 "a zero burst is a valid way to never answer"
2537 );
2538 }
2539
2540 #[cfg(feature = "serde")]
2541 #[test]
2542 fn refusal_reply_budget_rejects_unknown_fields() {
2543 assert!(serde_saphyr::from_str::<SessionGlobalConfig>("refusal_reply_budget: { burts: 5 }").is_err());
2544 }
2545
2546 #[test]
2547 fn stream_protocol_config_default_has_expected_values() {
2548 let cfg = StreamProtocolConfig::default();
2549 assert_eq!(cfg.per_peer_channel_capacity, DEFAULT_PER_PEER_CHANNEL_CAPACITY);
2550 assert_eq!(cfg.stream_open_timeout, DEFAULT_STREAM_OPEN_TIMEOUT);
2551 assert_eq!(
2552 cfg.frame_writer_backpressure_bytes,
2553 DEFAULT_FRAME_WRITER_BACKPRESSURE_BYTES
2554 );
2555 cfg.validate().expect("default StreamProtocolConfig must be valid");
2556 }
2557
2558 #[test]
2559 fn stream_protocol_config_zero_capacity_is_rejected() {
2560 let cfg = StreamProtocolConfig {
2561 per_peer_channel_capacity: 0,
2562 ..Default::default()
2563 };
2564 assert!(cfg.validate().is_err());
2565 }
2566
2567 #[test]
2568 fn stream_protocol_config_zero_backpressure_bytes_is_rejected() {
2569 let cfg = StreamProtocolConfig {
2570 frame_writer_backpressure_bytes: 0,
2571 ..Default::default()
2572 };
2573 assert!(cfg.validate().is_err());
2574 }
2575
2576 #[test]
2577 fn stream_protocol_config_zero_stream_open_timeout_is_rejected() {
2578 let cfg = StreamProtocolConfig {
2579 stream_open_timeout: Duration::ZERO,
2580 ..Default::default()
2581 };
2582 assert!(cfg.validate().is_err());
2583 }
2584
2585 #[test]
2586 fn stream_protocol_config_zero_backpressure_timeout_is_rejected() {
2587 let cfg = StreamProtocolConfig {
2591 egress_backpressure_timeout: Duration::ZERO,
2592 ..Default::default()
2593 };
2594 assert!(cfg.validate().is_err());
2595 }
2596}