tycho-core 0.3.9

Basic functionality of peer.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use std::time::Duration;

use serde::{Deserialize, Serialize};
use tycho_util::serde_helpers;

#[derive(Default, Debug, Clone, Serialize, Deserialize)]
#[serde(default)]
#[non_exhaustive]
pub struct PublicOverlayClientConfig {
    /// Ordinary peers used to download blocks and other stuff.
    pub neighbors: NeighborsConfig,
    /// Validators as broadcast targets.
    pub validators: ValidatorsConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default)]
pub struct NeighborsConfig {
    /// The interval at which neighbours list is updated.
    ///
    /// Default: 2 minutes.
    #[serde(with = "serde_helpers::humantime")]
    pub update_interval: Duration,

    /// The interval at which current neighbours are pinged.
    ///
    /// Default: 30 seconds.
    #[serde(with = "serde_helpers::humantime")]
    pub ping_interval: Duration,

    /// The interval at which neighbours score is applied to selection index.
    ///
    /// Default: 10 seconds.
    #[serde(with = "serde_helpers::humantime")]
    pub apply_score_interval: Duration,

    /// The interval to export neighbours metrics.
    ///
    /// Default: 5 seconds.
    #[serde(with = "serde_helpers::humantime")]
    pub update_metrics_interval: Duration,

    /// The maximum number of neighbours to keep.
    ///
    /// Default: 5.
    pub keep: usize,

    /// The maximum number of ping tasks to run concurrently.
    ///
    /// Default: 5.
    pub max_ping_tasks: usize,

    /// The default roundtrip time to use when a neighbour is added.
    ///
    /// Default: 300 ms.
    #[serde(with = "serde_helpers::humantime")]
    pub default_roundtrip: Duration,

    /// Send timeout (unidirectional).
    ///
    /// Default: 500ms.
    #[serde(with = "serde_helpers::humantime")]
    pub send_timeout: Duration,

    /// Query timeout (bidirectional).
    ///
    /// Default: 1s.
    #[serde(with = "serde_helpers::humantime")]
    pub query_timeout: Duration,

    /// Whether to enable `Neighbours` metrics.
    ///
    /// Default: `true`.
    pub enable_metrics: bool,
}

impl Default for NeighborsConfig {
    fn default() -> Self {
        Self {
            update_interval: Duration::from_secs(2 * 60),
            ping_interval: Duration::from_secs(30),
            apply_score_interval: Duration::from_secs(10),
            update_metrics_interval: Duration::from_secs(5),
            keep: 5,
            max_ping_tasks: 5,
            default_roundtrip: Duration::from_millis(300),
            send_timeout: Duration::from_millis(500),
            query_timeout: Duration::from_secs(1),
            enable_metrics: true,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default)]
pub struct ValidatorsConfig {
    /// The interval at which target validators are pinged.
    ///
    /// Default: 60 seconds.
    #[serde(with = "serde_helpers::humantime")]
    pub ping_interval: Duration,

    /// The timeout for a ping.
    ///
    /// Default: 1 seconds.
    #[serde(with = "serde_helpers::humantime")]
    pub ping_timeout: Duration,

    /// The maximum number of validators to keep.
    ///
    /// Default: 5.
    pub keep: usize,

    /// The maximum number of ping tasks to run concurrently.
    ///
    /// Default: 5.
    pub max_ping_tasks: usize,

    /// Send timeout (unidirectional).
    ///
    /// Default: 500ms.
    #[serde(with = "serde_helpers::humantime")]
    pub send_timeout: Duration,
}

impl Default for ValidatorsConfig {
    fn default() -> Self {
        Self {
            ping_interval: Duration::from_secs(60),
            ping_timeout: Duration::from_secs(1),
            keep: 5,
            max_ping_tasks: 5,
            send_timeout: Duration::from_millis(500),
        }
    }
}