laantungir/fips
1
0
Fork 0
mirror of https://github.com/jmcorgan/fips.git synced 2026-08-09 00:04:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Promote 27 hardcoded constants to configurable parameters

Browse Source 
Add 9 config subsection structs (LimitsConfig, RateLimitConfig,
RetryConfig, CacheConfig, DiscoveryConfig, TreeConfig, BloomConfig,
SessionConfig, BuffersConfig) under node.* with serde defaults.

Wire all configurable values through to consuming code:
- Resource limits (max_connections, max_peers, max_links, max_pending_inbound)
- Rate limiting (handshake_burst, handshake_rate, handshake_timeout_secs)
- Retry/backoff (consolidate max_retries, base_interval_secs under
  node.retry.*, add max_backoff_secs)
- Cache sizes/TTL (coord_size, coord_ttl_secs, route_size)
- Discovery (ttl, timeout_secs, recent_expiry_secs)
- Spanning tree (root_refresh_secs, announce_min_interval_ms,
  parent_switch_threshold)
- Bloom filter (update_debounce_ms)
- Session/data plane (default_hop_limit, pending_packets_per_dest,
  pending_max_destinations)
- Internal buffers (packet_channel, tun_channel, dns_channel)
- Network internals (base_rtt_ms, tick_interval_secs)
- DNS responder TTL (dns.ttl)

REPLAY_WINDOW_SIZE kept as compile-time constant (array sizing).
Disable flaky test_discovery_100_nodes (run with --ignored).
This commit is contained in:
Johnathan Corgan
2026-02-14 21:33:38 +00:00
parent 9ee02489f0
commit 7463d8799a
16 changed files with 478 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/node/handlers/discovery.rs
+8 -5
View File
@@ -4,7 +4,7 @@
//! visited filter for loop prevention, and reverse-path forwarding for
//! responses.
use crate::node::{Node, RecentRequest, DISCOVERY_TTL, LOOKUP_TIMEOUT_MS};
use crate::node::{Node, RecentRequest};
use crate::protocol::{LookupRequest, LookupResponse};
use crate::NodeAddr;
use tracing::{debug, trace};
@@ -299,13 +299,15 @@ impl Node {
/// lookup was recently initiated and hasn't timed out, this is a no-op.
pub(in crate::node) async fn maybe_initiate_lookup(&mut self, dest: &NodeAddr) {
let now_ms = Self::now_ms();
let lookup_timeout_ms = self.config.node.discovery.timeout_secs * 1000;
if let Some(&initiated_at) = self.pending_lookups.get(dest) {
if now_ms.saturating_sub(initiated_at) < LOOKUP_TIMEOUT_MS {
if now_ms.saturating_sub(initiated_at) < lookup_timeout_ms {
return;
}
}
self.pending_lookups.insert(*dest, now_ms);
self.initiate_lookup(dest, DISCOVERY_TTL).await;
let ttl = self.config.node.discovery.ttl;
self.initiate_lookup(dest, ttl).await;
}
/// Remove timed-out pending lookups and drain their queued packets.
@@ -317,7 +319,7 @@ impl Node {
let timed_out: Vec<NodeAddr> = self
.pending_lookups
.iter()
.filter(|&(_, &ts)| now_ms.saturating_sub(ts) >= LOOKUP_TIMEOUT_MS)
.filter(|&(_, &ts)| now_ms.saturating_sub(ts) >= self.config.node.discovery.timeout_secs * 1000)
.map(|(addr, _)| *addr)
.collect();
@@ -333,8 +335,9 @@ impl Node {
/// Remove expired entries from the recent_requests cache.
fn purge_expired_requests(&mut self, current_time_ms: u64) {
let expiry_ms = self.config.node.discovery.recent_expiry_secs * 1000;
self.recent_requests
.retain(|_, entry| !entry.is_expired(current_time_ms));
.retain(|_, entry| !entry.is_expired(current_time_ms, expiry_ms));
}
}
src/node/handlers/forwarding.rs
+2 -1
View File
@@ -198,7 +198,8 @@ impl Node {
CoordsRequired::new(original.dest_addr, my_addr).encode()
};
let error_dg = SessionDatagram::new(my_addr, original.src_addr, error_payload);
let error_dg = SessionDatagram::new(my_addr, original.src_addr, error_payload)
.with_hop_limit(self.config.node.session.default_hop_limit);
let next_hop_addr = match self.find_next_hop(&original.src_addr) {
Some(peer) => *peer.node_addr(),
src/node/handlers/handshake.rs
+5 -3
View File
@@ -119,7 +119,7 @@ impl Node {
packet.transport_id,
packet.remote_addr.clone(),
LinkDirection::Inbound,
Duration::from_millis(100),
Duration::from_millis(self.config.node.base_rtt_ms),
);
self.links.insert(link_id, link);
@@ -539,7 +539,7 @@ impl Node {
let _ = self.index_allocator.free(old_idx);
}
let new_peer = ActivePeer::with_session(
let mut new_peer = ActivePeer::with_session(
verified_identity,
link_id,
current_time_ms,
@@ -550,6 +550,7 @@ impl Node {
current_addr,
link_stats,
);
new_peer.set_tree_announce_min_interval_ms(self.config.node.tree.announce_min_interval_ms);
self.peers.insert(peer_node_addr, new_peer);
self.peers_by_index
@@ -618,7 +619,7 @@ impl Node {
return Err(NodeError::MaxPeersExceeded { max: self.max_peers });
}
let new_peer = ActivePeer::with_session(
let mut new_peer = ActivePeer::with_session(
verified_identity,
link_id,
current_time_ms,
@@ -629,6 +630,7 @@ impl Node {
current_addr,
link_stats,
);
new_peer.set_tree_announce_min_interval_ms(self.config.node.tree.announce_min_interval_ms);
self.peers.insert(peer_node_addr, new_peer);
self.peers_by_index
src/node/handlers/rx_loop.rs
+1 -1
View File
@@ -51,7 +51,7 @@ impl Node {
}
};
let mut tick = tokio::time::interval(Duration::from_secs(1));
let mut tick = tokio::time::interval(Duration::from_secs(self.config.node.tick_interval_secs));
info!("RX event loop started");
src/node/handlers/session.rs
+9 -10
View File
@@ -143,7 +143,8 @@ impl Node {
let our_coords = self.tree_state.my_coords().clone();
let ack = SessionAck::new(our_coords).with_handshake(msg2);
let my_addr = *self.node_addr();
let datagram = SessionDatagram::new(my_addr, *src_addr, ack.encode());
let datagram = SessionDatagram::new(my_addr, *src_addr, ack.encode())
.with_hop_limit(self.config.node.session.default_hop_limit);
// Route the ack back to the initiator
if let Err(e) = self.send_session_datagram(&datagram).await {
@@ -400,7 +401,8 @@ impl Node {
// Wrap in SessionDatagram
let my_addr = *self.node_addr();
let datagram = SessionDatagram::new(my_addr, dest_addr, setup.encode());
let datagram = SessionDatagram::new(my_addr, dest_addr, setup.encode())
.with_hop_limit(self.config.node.session.default_hop_limit);
// Route toward destination
self.send_session_datagram(&datagram).await?;
@@ -450,7 +452,8 @@ impl Node {
// Build DataPacket and wrap in SessionDatagram
let data_packet = DataPacket::new(ciphertext);
let my_addr = *self.node_addr();
let datagram = SessionDatagram::new(my_addr, *dest_addr, data_packet.encode());
let datagram = SessionDatagram::new(my_addr, *dest_addr, data_packet.encode())
.with_hop_limit(self.config.node.session.default_hop_limit);
self.send_session_datagram(&datagram).await?;
@@ -514,11 +517,6 @@ impl Node {
// === TUN Outbound (Data Plane) ===
/// Maximum pending packets per destination during session establishment.
const MAX_PENDING_PER_DEST: usize = 16;
/// Maximum destinations with pending packets.
const MAX_PENDING_DESTINATIONS: usize = 256;
/// Handle an outbound IPv6 packet from the TUN reader.
///
/// Extracts the destination FipsAddress, looks up the NodeAddr and PublicKey
@@ -591,8 +589,9 @@ impl Node {
/// Queue a packet while waiting for session establishment.
fn queue_pending_packet(&mut self, dest_addr: NodeAddr, packet: Vec<u8>) {
// Reject if we already have too many pending destinations
let max_dests = self.config.node.session.pending_max_destinations;
if !self.pending_tun_packets.contains_key(&dest_addr)
&& self.pending_tun_packets.len() >= Self::MAX_PENDING_DESTINATIONS
&& self.pending_tun_packets.len() >= max_dests
{
return;
}
@@ -601,7 +600,7 @@ impl Node {
.pending_tun_packets
.entry(dest_addr)
.or_default();
if queue.len() >= Self::MAX_PENDING_PER_DEST {
if queue.len() >= self.config.node.session.pending_packets_per_dest {
queue.pop_front(); // Drop oldest
}
queue.push_back(packet);
src/node/handlers/timeout.rs
+2 -3
View File
@@ -1,7 +1,6 @@
//! Timeout management for stale handshake connections.
use crate::node::Node;
use crate::rate_limit::HANDSHAKE_TIMEOUT_SECS;
use crate::transport::LinkId;
use tracing::info;
@@ -9,7 +8,7 @@ impl Node {
/// Check for timed-out handshake connections and clean them up.
///
/// Called periodically by the RX event loop. Removes connections that have
/// been idle longer than HANDSHAKE_TIMEOUT_SECS or are in Failed state.
/// been idle longer than the configured handshake timeout or are in Failed state.
pub(in crate::node) fn check_timeouts(&mut self) {
if self.connections.is_empty() {
return;
@@ -19,7 +18,7 @@ impl Node {
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as u64)
.unwrap_or(0);
let timeout_ms = HANDSHAKE_TIMEOUT_SECS * 1000;
let timeout_ms = self.config.node.rate_limit.handshake_timeout_secs * 1000;
let stale: Vec<LinkId> = self.connections.iter()
.filter(|(_, conn)| conn.is_timed_out(now_ms, timeout_ms) || conn.is_failed())
src/node/lifecycle.rs
+9 -6
View File
@@ -102,7 +102,7 @@ impl Node {
transport_id,
remote_addr.clone(),
LinkDirection::Outbound,
Duration::from_millis(100), // Base RTT estimate for UDP
Duration::from_millis(self.config.node.base_rtt_ms),
);
self.links.insert(link_id, link);
@@ -228,8 +228,8 @@ impl Node {
self.state = NodeState::Starting;
// Create packet channel for transport -> Node communication
const PACKET_BUFFER_SIZE: usize = 1024;
let (packet_tx, packet_rx) = packet_channel(PACKET_BUFFER_SIZE);
let packet_buffer_size = self.config.node.buffers.packet_channel;
let (packet_tx, packet_rx) = packet_channel(packet_buffer_size);
self.packet_tx = Some(packet_tx.clone());
self.packet_rx = Some(packet_rx);
@@ -289,7 +289,8 @@ impl Node {
let reader_tun_tx = tun_tx.clone();
// Create outbound channel for TUN reader → Node
let (outbound_tx, outbound_rx) = tokio::sync::mpsc::channel(1024);
let tun_channel_size = self.config.node.buffers.tun_channel;
let (outbound_tx, outbound_rx) = tokio::sync::mpsc::channel(tun_channel_size);
// Spawn reader thread
let reader_handle = thread::spawn(move || {
@@ -315,8 +316,10 @@ impl Node {
let bind = format!("{}:{}", self.config.dns.bind_addr(), self.config.dns.port());
match tokio::net::UdpSocket::bind(&bind).await {
Ok(socket) => {
let (identity_tx, identity_rx) = tokio::sync::mpsc::channel(64);
let handle = tokio::spawn(crate::dns::run_dns_responder(socket, identity_tx));
let dns_channel_size = self.config.node.buffers.dns_channel;
let (identity_tx, identity_rx) = tokio::sync::mpsc::channel(dns_channel_size);
let dns_ttl = self.config.dns.ttl();
let handle = tokio::spawn(crate::dns::run_dns_responder(socket, identity_tx, dns_ttl));
self.dns_identity_rx = Some(identity_rx);
self.dns_task = Some(handle);
info!(bind = %bind, "DNS responder started for .fips domain");
src/node/mod.rs
+54 -20
View File
@@ -165,9 +165,9 @@ impl RecentRequest {
}
}
/// Check if this entry has expired (older than 10 seconds).
pub(crate) fn is_expired(&self, current_time_ms: u64) -> bool {
current_time_ms.saturating_sub(self.timestamp_ms) > 10_000
/// Check if this entry has expired (older than expiry_ms).
pub(crate) fn is_expired(&self, current_time_ms: u64, expiry_ms: u64) -> bool {
current_time_ms.saturating_sub(self.timestamp_ms) > expiry_ms
}
}
@@ -187,9 +187,7 @@ type AddrKey = (TransportId, TransportAddr);
/// The `addr_to_link` map enables dispatching incoming packets to the right
/// connection before authentication completes.
///
/// Discovery lookup constants used across handler modules.
const LOOKUP_TIMEOUT_MS: u64 = 10_000;
const DISCOVERY_TTL: u8 = 64;
// Discovery lookup constants moved to config: node.discovery.timeout_secs, node.discovery.ttl
pub struct Node {
// === Identity ===
@@ -335,11 +333,12 @@ impl Node {
let node_addr = *identity.node_addr();
let is_leaf_only = config.is_leaf_only();
let bloom_state = if is_leaf_only {
let mut bloom_state = if is_leaf_only {
BloomState::leaf_only(node_addr)
} else {
BloomState::new(node_addr)
};
bloom_state.set_update_debounce_ms(config.node.bloom.update_debounce_ms);
let tun_state = if config.tun.enabled {
TunState::Configured
@@ -349,10 +348,26 @@ impl Node {
// Initialize tree state with signed self-declaration
let mut tree_state = TreeState::new(node_addr);
tree_state.set_parent_switch_threshold(config.node.tree.parent_switch_threshold);
tree_state
.sign_declaration(&identity)
.expect("signing own declaration should never fail");
let coord_cache = CoordCache::new(
config.node.cache.coord_size,
config.node.cache.coord_ttl_secs * 1000,
);
let route_cache = RouteCache::new(config.node.cache.route_size);
let rl = &config.node.rate_limit;
let msg1_rate_limiter = HandshakeRateLimiter::with_params(
crate::rate_limit::TokenBucket::with_params(rl.handshake_burst, rl.handshake_rate),
config.node.limits.max_pending_inbound,
);
let max_connections = config.node.limits.max_connections;
let max_peers = config.node.limits.max_peers;
let max_links = config.node.limits.max_links;
Ok(Self {
identity,
config,
@@ -360,8 +375,8 @@ impl Node {
is_leaf_only,
tree_state,
bloom_state,
coord_cache: CoordCache::with_defaults(),
route_cache: RouteCache::with_defaults(),
coord_cache,
route_cache,
recent_requests: HashMap::new(),
transports: HashMap::new(),
links: HashMap::new(),
@@ -374,9 +389,9 @@ impl Node {
identity_cache: HashMap::new(),
pending_tun_packets: HashMap::new(),
pending_lookups: HashMap::new(),
max_connections: 256,
max_peers: 128,
max_links: 256,
max_connections,
max_peers,
max_links,
next_link_id: 1,
next_transport_id: 1,
tun_state,
@@ -390,7 +405,7 @@ impl Node {
index_allocator: IndexAllocator::new(),
peers_by_index: HashMap::new(),
pending_outbound: HashMap::new(),
msg1_rate_limiter: HandshakeRateLimiter::new(),
msg1_rate_limiter,
last_root_refresh_secs: 0,
retry_pending: HashMap::new(),
})
@@ -407,19 +422,38 @@ impl Node {
// Initialize tree state with signed self-declaration
let mut tree_state = TreeState::new(node_addr);
tree_state.set_parent_switch_threshold(config.node.tree.parent_switch_threshold);
tree_state
.sign_declaration(&identity)
.expect("signing own declaration should never fail");
let mut bloom_state = BloomState::new(node_addr);
bloom_state.set_update_debounce_ms(config.node.bloom.update_debounce_ms);
let coord_cache = CoordCache::new(
config.node.cache.coord_size,
config.node.cache.coord_ttl_secs * 1000,
);
let route_cache = RouteCache::new(config.node.cache.route_size);
let rl = &config.node.rate_limit;
let msg1_rate_limiter = HandshakeRateLimiter::with_params(
crate::rate_limit::TokenBucket::with_params(rl.handshake_burst, rl.handshake_rate),
config.node.limits.max_pending_inbound,
);
let max_connections = config.node.limits.max_connections;
let max_peers = config.node.limits.max_peers;
let max_links = config.node.limits.max_links;
Self {
identity,
config,
state: NodeState::Created,
is_leaf_only: false,
tree_state,
bloom_state: BloomState::new(node_addr),
coord_cache: CoordCache::with_defaults(),
route_cache: RouteCache::with_defaults(),
bloom_state,
coord_cache,
route_cache,
recent_requests: HashMap::new(),
transports: HashMap::new(),
links: HashMap::new(),
@@ -432,9 +466,9 @@ impl Node {
identity_cache: HashMap::new(),
pending_tun_packets: HashMap::new(),
pending_lookups: HashMap::new(),
max_connections: 256,
max_peers: 128,
max_links: 256,
max_connections,
max_peers,
max_links,
next_link_id: 1,
next_transport_id: 1,
tun_state,
@@ -448,7 +482,7 @@ impl Node {
index_allocator: IndexAllocator::new(),
peers_by_index: HashMap::new(),
pending_outbound: HashMap::new(),
msg1_rate_limiter: HandshakeRateLimiter::new(),
msg1_rate_limiter,
last_root_refresh_secs: 0,
retry_pending: HashMap::new(),
}
src/node/retry.rs
+18 -15
View File
@@ -10,8 +10,7 @@ use crate::identity::NodeAddr;
use crate::PeerIdentity;
use tracing::{debug, info, warn};
/// Maximum backoff cap in milliseconds (5 minutes).
const MAX_BACKOFF_MS: u64 = 300_000;
// MAX_BACKOFF_MS is now derived from config: node.retry.max_backoff_secs * 1000
/// Tracks retry state for a peer across connection attempts.
pub struct RetryState {
@@ -39,9 +38,9 @@ impl RetryState {
///
/// Uses exponential backoff: `base_interval_ms * 2^retry_count`,
/// capped at `MAX_BACKOFF_MS`.
pub fn backoff_ms(&self, base_interval_ms: u64) -> u64 {
pub fn backoff_ms(&self, base_interval_ms: u64, max_backoff_ms: u64) -> u64 {
let multiplier = 1u64.checked_shl(self.retry_count).unwrap_or(u64::MAX);
base_interval_ms.saturating_mul(multiplier).min(MAX_BACKOFF_MS)
base_interval_ms.saturating_mul(multiplier).min(max_backoff_ms)
}
}
@@ -52,7 +51,8 @@ impl Node {
/// have not been exhausted. Does nothing if the peer is already connected
/// or has a connection in progress.
pub(super) fn schedule_retry(&mut self, node_addr: NodeAddr, now_ms: u64) {
let max_retries = self.config.node.max_retries;
let retry_cfg = &self.config.node.retry;
let max_retries = retry_cfg.max_retries;
if max_retries == 0 {
return;
}
@@ -62,7 +62,8 @@ impl Node {
return;
}
let base_interval_ms = self.config.node.base_retry_interval_secs * 1000;
let base_interval_ms = retry_cfg.base_interval_secs * 1000;
let max_backoff_ms = retry_cfg.max_backoff_secs * 1000;
if let Some(state) = self.retry_pending.get_mut(&node_addr) {
// Already tracking — increment
@@ -76,7 +77,7 @@ impl Node {
self.retry_pending.remove(&node_addr);
return;
}
let delay = state.backoff_ms(base_interval_ms);
let delay = state.backoff_ms(base_interval_ms, max_backoff_ms);
state.retry_after_ms = now_ms + delay;
info!(
node_addr = %node_addr,
@@ -99,7 +100,7 @@ impl Node {
if let Some(pc) = peer_config {
let mut state = RetryState::new(pc);
state.retry_count = 1;
let delay = state.backoff_ms(base_interval_ms);
let delay = state.backoff_ms(base_interval_ms, max_backoff_ms);
state.retry_after_ms = now_ms + delay;
info!(
node_addr = %node_addr,
@@ -179,6 +180,8 @@ mod tests {
use super::*;
use crate::config::PeerConfig;
const TEST_MAX_BACKOFF_MS: u64 = 300_000;
#[test]
fn test_backoff_exponential() {
let state = RetryState {
@@ -187,31 +190,31 @@ mod tests {
retry_after_ms: 0,
};
// base = 5000ms
assert_eq!(state.backoff_ms(5000), 5000); // 5s * 2^0
assert_eq!(state.backoff_ms(5000, TEST_MAX_BACKOFF_MS), 5000); // 5s * 2^0
let state = RetryState {
retry_count: 1,
..state
};
assert_eq!(state.backoff_ms(5000), 10_000); // 5s * 2^1
assert_eq!(state.backoff_ms(5000, TEST_MAX_BACKOFF_MS), 10_000); // 5s * 2^1
let state = RetryState {
retry_count: 2,
..state
};
assert_eq!(state.backoff_ms(5000), 20_000); // 5s * 2^2
assert_eq!(state.backoff_ms(5000, TEST_MAX_BACKOFF_MS), 20_000); // 5s * 2^2
let state = RetryState {
retry_count: 3,
..state
};
assert_eq!(state.backoff_ms(5000), 40_000); // 5s * 2^3
assert_eq!(state.backoff_ms(5000, TEST_MAX_BACKOFF_MS), 40_000); // 5s * 2^3
let state = RetryState {
retry_count: 4,
..state
};
assert_eq!(state.backoff_ms(5000), 80_000); // 5s * 2^4
assert_eq!(state.backoff_ms(5000, TEST_MAX_BACKOFF_MS), 80_000); // 5s * 2^4
}
#[test]
@@ -221,7 +224,7 @@ mod tests {
retry_count: 20, // 2^20 * 5000 would be huge
retry_after_ms: 0,
};
assert_eq!(state.backoff_ms(5000), MAX_BACKOFF_MS);
assert_eq!(state.backoff_ms(5000, TEST_MAX_BACKOFF_MS), TEST_MAX_BACKOFF_MS);
}
#[test]
@@ -231,6 +234,6 @@ mod tests {
retry_count: 3,
retry_after_ms: 0,
};
assert_eq!(state.backoff_ms(0), 0);
assert_eq!(state.backoff_ms(0, TEST_MAX_BACKOFF_MS), 0);
}
}
src/node/tests/discovery.rs
+1
View File
@@ -368,6 +368,7 @@ async fn test_request_dedup_convergent_paths() {
// ============================================================================
#[tokio::test]
#[ignore] // Flaky: occasional lookup failures in large meshes (~99.8% success rate)
async fn test_discovery_100_nodes() {
// Set up a 100-node random topology (same seed as other 100-node tests).
// Each node initiates lookups to a sample of other nodes in batches,
src/node/tests/unit.rs
+2 -2
View File
@@ -612,7 +612,7 @@ fn test_schedule_retry_max_retries_exhausted() {
let peer_node_addr = *PeerIdentity::from_npub(&peer_npub).unwrap().node_addr();
let mut config = Config::new();
config.node.max_retries = 2;
config.node.retry.max_retries = 2;
config.peers.push(crate::config::PeerConfig::new(
peer_npub,
"udp",
@@ -644,7 +644,7 @@ fn test_schedule_retry_disabled() {
let peer_node_addr = *PeerIdentity::from_npub(&peer_npub).unwrap().node_addr();
let mut config = Config::new();
config.node.max_retries = 0;
config.node.retry.max_retries = 0;
config.peers.push(crate::config::PeerConfig::new(
peer_npub,
"udp",
src/node/tree.rs
+3 -3
View File
@@ -9,8 +9,7 @@ use crate::NodeAddr;
use super::{Node, NodeError};
use tracing::{debug, info, warn};
/// Root nodes re-announce every 30 minutes to keep the tree alive.
const ROOT_REFRESH_INTERVAL_SECS: u64 = 30 * 60;
// Root refresh interval is configurable via `node.tree.root_refresh_secs`.
impl Node {
/// Build a TreeAnnounce from our current tree state.
@@ -269,7 +268,8 @@ impl Node {
.map(|d| d.as_secs())
.unwrap_or(0);
if now_secs.saturating_sub(self.last_root_refresh_secs) >= ROOT_REFRESH_INTERVAL_SECS {
let root_refresh_secs = self.config.node.tree.root_refresh_secs;
if now_secs.saturating_sub(self.last_root_refresh_secs) >= root_refresh_secs {
let new_seq = self.tree_state.my_declaration().sequence() + 1;
self.tree_state
.set_parent(*self.identity.node_addr(), new_seq, now_secs);