503 lines
17 KiB
Rust
503 lines
17 KiB
Rust
//! Peer database and consensus validation for tracking remote peers and their games.
|
|
|
|
use std::{
|
|
cmp::Reverse,
|
|
collections::HashMap,
|
|
net::SocketAddr,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
use lanspread_db::db::{Game, GameFileDescription};
|
|
|
|
/// Information about a discovered peer.
|
|
#[derive(Clone, Debug)]
|
|
pub struct PeerInfo {
|
|
/// Network address of the peer.
|
|
pub addr: SocketAddr,
|
|
/// Last time we heard from this peer.
|
|
pub last_seen: Instant,
|
|
/// Games this peer has available, keyed by game ID.
|
|
pub games: HashMap<String, Game>,
|
|
/// File descriptions for each game, keyed by game ID.
|
|
pub files: HashMap<String, Vec<GameFileDescription>>,
|
|
}
|
|
|
|
/// Database tracking all discovered peers and their games.
|
|
#[derive(Debug)]
|
|
pub struct PeerGameDB {
|
|
peers: HashMap<SocketAddr, PeerInfo>,
|
|
}
|
|
|
|
impl Default for PeerGameDB {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl PeerGameDB {
|
|
#[must_use]
|
|
pub fn new() -> Self {
|
|
Self {
|
|
peers: HashMap::new(),
|
|
}
|
|
}
|
|
|
|
/// Adds a new peer to the database.
|
|
pub fn add_peer(&mut self, addr: SocketAddr) {
|
|
let peer_info = PeerInfo {
|
|
addr,
|
|
last_seen: Instant::now(),
|
|
games: HashMap::new(),
|
|
files: HashMap::new(),
|
|
};
|
|
self.peers.insert(addr, peer_info);
|
|
log::info!("Added peer: {addr}");
|
|
}
|
|
|
|
/// Removes a peer from the database.
|
|
pub fn remove_peer(&mut self, addr: &SocketAddr) -> Option<PeerInfo> {
|
|
self.peers.remove(addr)
|
|
}
|
|
|
|
/// Updates the games list for a peer.
|
|
pub fn update_peer_games(&mut self, addr: SocketAddr, games: Vec<Game>) {
|
|
if let Some(peer) = self.peers.get_mut(&addr) {
|
|
let mut map = HashMap::with_capacity(games.len());
|
|
for game in games {
|
|
map.insert(game.id.clone(), game);
|
|
}
|
|
peer.games = map;
|
|
peer.last_seen = Instant::now();
|
|
log::info!("Updated games for peer: {addr}");
|
|
}
|
|
}
|
|
|
|
/// Updates the file descriptions for a specific game from a peer.
|
|
pub fn update_peer_game_files(
|
|
&mut self,
|
|
addr: SocketAddr,
|
|
game_id: &str,
|
|
files: Vec<GameFileDescription>,
|
|
) {
|
|
if let Some(peer) = self.peers.get_mut(&addr) {
|
|
peer.files.insert(game_id.to_string(), files);
|
|
peer.last_seen = Instant::now();
|
|
}
|
|
}
|
|
|
|
/// Updates the last seen timestamp for a peer.
|
|
pub fn update_last_seen(&mut self, addr: &SocketAddr) {
|
|
if let Some(peer) = self.peers.get_mut(addr) {
|
|
peer.last_seen = Instant::now();
|
|
}
|
|
}
|
|
|
|
/// Returns all games aggregated from all peers.
|
|
#[must_use]
|
|
pub fn get_all_games(&self) -> Vec<Game> {
|
|
let mut aggregated: HashMap<String, Game> = HashMap::new();
|
|
let mut peer_counts: HashMap<String, u32> = HashMap::new();
|
|
|
|
// Count peers per game
|
|
for peer in self.peers.values() {
|
|
for game_id in peer.games.keys() {
|
|
*peer_counts.entry(game_id.clone()).or_insert(0) += 1;
|
|
}
|
|
}
|
|
|
|
// Aggregate games with peer counts
|
|
for peer in self.peers.values() {
|
|
for game in peer.games.values() {
|
|
aggregated
|
|
.entry(game.id.clone())
|
|
.and_modify(|existing| {
|
|
if let (Some(new_version), Some(current)) =
|
|
(&game.eti_game_version, &existing.eti_game_version)
|
|
{
|
|
if new_version > current {
|
|
existing.eti_game_version = Some(new_version.clone());
|
|
}
|
|
} else if existing.eti_game_version.is_none() {
|
|
existing.eti_game_version.clone_from(&game.eti_game_version);
|
|
}
|
|
// Update peer count
|
|
existing.peer_count = peer_counts[&game.id];
|
|
})
|
|
.or_insert_with(|| {
|
|
let mut game_clone = game.clone();
|
|
game_clone.peer_count = peer_counts[&game.id];
|
|
game_clone
|
|
});
|
|
}
|
|
}
|
|
|
|
let mut games: Vec<Game> = aggregated.into_values().collect();
|
|
games.sort_by(|a, b| a.name.cmp(&b.name));
|
|
games
|
|
}
|
|
|
|
/// Returns the latest version of a game across all peers.
|
|
#[must_use]
|
|
pub fn get_latest_version_for_game(&self, game_id: &str) -> Option<String> {
|
|
let mut latest_version: Option<String> = None;
|
|
|
|
for peer in self.peers.values() {
|
|
if let Some(game) = peer.games.get(game_id)
|
|
&& let Some(ref version) = game.eti_game_version
|
|
{
|
|
match &latest_version {
|
|
None => latest_version = Some(version.clone()),
|
|
Some(current_latest) => {
|
|
if version > current_latest {
|
|
latest_version = Some(version.clone());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
latest_version
|
|
}
|
|
|
|
/// Returns all peer addresses.
|
|
#[must_use]
|
|
pub fn get_peer_addresses(&self) -> Vec<SocketAddr> {
|
|
self.peers.keys().copied().collect()
|
|
}
|
|
|
|
/// Checks if a peer is in the database.
|
|
#[must_use]
|
|
pub fn contains_peer(&self, addr: &SocketAddr) -> bool {
|
|
self.peers.contains_key(addr)
|
|
}
|
|
|
|
/// Returns addresses of peers that have a specific game.
|
|
#[must_use]
|
|
pub fn peers_with_game(&self, game_id: &str) -> Vec<SocketAddr> {
|
|
self.peers
|
|
.iter()
|
|
.filter(|(_, peer)| peer.games.contains_key(game_id))
|
|
.map(|(addr, _)| *addr)
|
|
.collect()
|
|
}
|
|
|
|
/// Returns addresses of peers that have the latest version of a game.
|
|
#[must_use]
|
|
pub fn peers_with_latest_version(&self, game_id: &str) -> Vec<SocketAddr> {
|
|
let latest_version = self.get_latest_version_for_game(game_id);
|
|
|
|
if let Some(ref latest) = latest_version {
|
|
self.peers
|
|
.iter()
|
|
.filter(|(_, peer)| {
|
|
if let Some(game) = peer.games.get(game_id) {
|
|
if let Some(ref version) = game.eti_game_version {
|
|
version == latest
|
|
} else {
|
|
false
|
|
}
|
|
} else {
|
|
false
|
|
}
|
|
})
|
|
.map(|(addr, _)| *addr)
|
|
.collect()
|
|
} else {
|
|
// If no version info is available, fall back to all peers with the game
|
|
self.peers_with_game(game_id)
|
|
}
|
|
}
|
|
|
|
/// Returns file descriptions for a game from all peers.
|
|
#[must_use]
|
|
pub fn game_files_for(&self, game_id: &str) -> Vec<(SocketAddr, Vec<GameFileDescription>)> {
|
|
self.peers
|
|
.iter()
|
|
.filter_map(|(addr, peer)| peer.files.get(game_id).cloned().map(|files| (*addr, files)))
|
|
.collect()
|
|
}
|
|
|
|
/// Returns aggregated file descriptions for a game across all peers.
|
|
#[must_use]
|
|
pub fn aggregated_game_files(&self, game_id: &str) -> Vec<GameFileDescription> {
|
|
let mut seen: HashMap<String, GameFileDescription> = HashMap::new();
|
|
for (_, files) in self.game_files_for(game_id) {
|
|
for file in files {
|
|
seen.entry(file.relative_path.clone()).or_insert(file);
|
|
}
|
|
}
|
|
seen.into_values().collect()
|
|
}
|
|
|
|
/// Returns the majority-agreed size for a game.
|
|
#[must_use]
|
|
pub fn majority_game_size(&self, game_id: &str) -> Option<u64> {
|
|
let mut size_counts: HashMap<u64, usize> = HashMap::new();
|
|
|
|
for peer in self.peers.values() {
|
|
if let Some(game) = peer.games.get(game_id) {
|
|
if game.size == 0 {
|
|
continue;
|
|
}
|
|
*size_counts.entry(game.size).or_insert(0) += 1;
|
|
}
|
|
}
|
|
|
|
size_counts
|
|
.into_iter()
|
|
.max_by(|(size_a, count_a), (size_b, count_b)| {
|
|
count_a.cmp(count_b).then_with(|| size_a.cmp(size_b))
|
|
})
|
|
.map(|(size, _)| size)
|
|
}
|
|
|
|
/// Validates file sizes across all peers and returns only the files with majority consensus.
|
|
///
|
|
/// Returns a tuple of (`validated_files`, `peer_whitelist`, `file_peer_map`) where
|
|
/// `peer_whitelist` contains peers that have at least one majority-approved file and
|
|
/// `file_peer_map` lists which peers were validated for each file.
|
|
pub fn validate_file_sizes_majority(
|
|
&self,
|
|
game_id: &str,
|
|
) -> eyre::Result<MajorityValidationResult> {
|
|
let game_files = self.game_files_for(game_id);
|
|
if game_files.is_empty() {
|
|
return Ok((Vec::new(), Vec::new(), HashMap::new()));
|
|
}
|
|
|
|
let (file_size_map, _peer_files) = collect_file_sizes(&game_files);
|
|
let (validated_files, peer_scores, file_peer_map) =
|
|
self.validate_each_file_consensus(game_id, file_size_map)?;
|
|
let peer_whitelist = create_peer_whitelist(peer_scores);
|
|
|
|
Ok((validated_files, peer_whitelist, file_peer_map))
|
|
}
|
|
|
|
/// Validates consensus for each file and returns validated files with peer scores.
|
|
fn validate_each_file_consensus(
|
|
&self,
|
|
game_id: &str,
|
|
file_size_map: FileSizeMap,
|
|
) -> eyre::Result<FileConsensusAggregation> {
|
|
let mut validated_files = Vec::new();
|
|
let mut peer_whitelist_scores: HashMap<SocketAddr, usize> = HashMap::new();
|
|
let mut file_peer_map: HashMap<String, Vec<SocketAddr>> = HashMap::new();
|
|
|
|
for (relative_path, size_map) in file_size_map {
|
|
let total_peers: usize = size_map.values().map(Vec::len).sum();
|
|
|
|
if total_peers == 0 {
|
|
continue; // Skip files with no size information
|
|
}
|
|
|
|
let (consensus_size, consensus_peers) =
|
|
self.determine_size_consensus(&size_map, total_peers, &relative_path)?;
|
|
update_peer_scores(&consensus_peers, &mut peer_whitelist_scores);
|
|
|
|
if let Some((size, peers)) = consensus_size
|
|
&& let Some(file_desc) =
|
|
self.create_validated_file_description(game_id, &relative_path, size, &peers)
|
|
{
|
|
file_peer_map.insert(relative_path.clone(), peers.clone());
|
|
validated_files.push(file_desc);
|
|
}
|
|
}
|
|
|
|
Ok((validated_files, peer_whitelist_scores, file_peer_map))
|
|
}
|
|
|
|
/// Determines the consensus size for a file based on peer reports.
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// Panics if `size_map.iter().next()` returns None when `total_peers` == 1
|
|
#[allow(clippy::unused_self)]
|
|
fn determine_size_consensus(
|
|
&self,
|
|
size_map: &HashMap<u64, Vec<SocketAddr>>,
|
|
total_peers: usize,
|
|
relative_path: &str,
|
|
) -> eyre::Result<(ConsensusResult, Vec<SocketAddr>)> {
|
|
if total_peers == 1 {
|
|
// Only one peer has this file - trust it
|
|
let (&size, peers) = size_map
|
|
.iter()
|
|
.next()
|
|
.expect("size_map should have at least one entry when total_peers == 1");
|
|
return Ok((Some((size, peers.clone())), peers.clone()));
|
|
}
|
|
|
|
let (majority_size, _majority_count) = find_majority_size(size_map);
|
|
|
|
if let Some(size) = majority_size {
|
|
let majority_peers = &size_map[&size];
|
|
let is_majority = majority_peers.len() > total_peers / 2;
|
|
|
|
if is_majority {
|
|
// We have a clear majority
|
|
Ok((Some((size, majority_peers.clone())), majority_peers.clone()))
|
|
} else if total_peers == 2 {
|
|
// Two peers with different sizes - ambiguous, fail
|
|
eyre::bail!(
|
|
"File size ambiguity for '{}': two peers report different sizes, cannot determine majority",
|
|
relative_path
|
|
);
|
|
}
|
|
// If no majority and more than 2 peers, we fall back to plurality (largest group)
|
|
else {
|
|
Ok((Some((size, majority_peers.clone())), majority_peers.clone()))
|
|
}
|
|
} else {
|
|
// No clear majority and it's a tie between different sizes
|
|
if total_peers == 2 {
|
|
eyre::bail!(
|
|
"File size ambiguity for '{}': two peers report different sizes, cannot determine majority",
|
|
relative_path
|
|
);
|
|
}
|
|
// For more than 2 peers, we could fall back to plurality, but for now let's be strict
|
|
eyre::bail!(
|
|
"File size ambiguity for '{}': no clear majority among {} peers",
|
|
relative_path,
|
|
total_peers
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Creates a validated file description from consensus data.
|
|
fn create_validated_file_description(
|
|
&self,
|
|
game_id: &str,
|
|
relative_path: &str,
|
|
size: u64,
|
|
peers: &[SocketAddr],
|
|
) -> Option<GameFileDescription> {
|
|
if let Some(first_peer) = peers.first()
|
|
&& let Some(files) = self
|
|
.peers
|
|
.get(first_peer)
|
|
.and_then(|p| p.files.get(game_id))
|
|
&& let Some(file_desc) = files
|
|
.iter()
|
|
.find(|f| f.relative_path == relative_path && f.size == size)
|
|
{
|
|
return Some(file_desc.clone());
|
|
}
|
|
None
|
|
}
|
|
|
|
/// Returns peers that haven't been seen within the timeout duration.
|
|
#[must_use]
|
|
pub fn get_stale_peers(&self, timeout: Duration) -> Vec<SocketAddr> {
|
|
self.peers
|
|
.iter()
|
|
.filter(|(_, peer)| peer.last_seen.elapsed() > timeout)
|
|
.map(|(addr, _)| *addr)
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
// =============================================================================
|
|
// Type aliases for consensus validation
|
|
// =============================================================================
|
|
|
|
/// Type alias for file size mapping: path -> size -> peers
|
|
type FileSizeMap = HashMap<String, HashMap<u64, Vec<SocketAddr>>>;
|
|
|
|
/// Type alias for peer file mapping: peer -> path -> size
|
|
type PeerFileMap = HashMap<SocketAddr, HashMap<String, u64>>;
|
|
|
|
/// Type alias for consensus result: (size, peers) or None
|
|
type ConsensusResult = Option<(u64, Vec<SocketAddr>)>;
|
|
|
|
/// Type alias for the aggregated majority validation result.
|
|
pub type MajorityValidationResult = (
|
|
Vec<GameFileDescription>,
|
|
Vec<SocketAddr>,
|
|
HashMap<String, Vec<SocketAddr>>,
|
|
);
|
|
|
|
/// Type alias for per-file consensus aggregation results.
|
|
type FileConsensusAggregation = (
|
|
Vec<GameFileDescription>,
|
|
HashMap<SocketAddr, usize>,
|
|
HashMap<String, Vec<SocketAddr>>,
|
|
);
|
|
|
|
// =============================================================================
|
|
// Helper functions for consensus validation
|
|
// =============================================================================
|
|
|
|
/// Collects file sizes from all peers and organizes them by path and size.
|
|
fn collect_file_sizes(
|
|
game_files: &[(SocketAddr, Vec<GameFileDescription>)],
|
|
) -> (FileSizeMap, PeerFileMap) {
|
|
let mut file_size_map: FileSizeMap = HashMap::new();
|
|
let mut peer_files: PeerFileMap = HashMap::new();
|
|
|
|
for (peer_addr, files) in game_files {
|
|
let mut peer_file_sizes = HashMap::new();
|
|
for file in files {
|
|
if !file.is_dir {
|
|
let size = file.size;
|
|
file_size_map
|
|
.entry(file.relative_path.clone())
|
|
.or_default()
|
|
.entry(size)
|
|
.or_default()
|
|
.push(*peer_addr);
|
|
peer_file_sizes.insert(file.relative_path.clone(), size);
|
|
}
|
|
}
|
|
peer_files.insert(*peer_addr, peer_file_sizes);
|
|
}
|
|
|
|
(file_size_map, peer_files)
|
|
}
|
|
|
|
/// Finds the majority size from a map of sizes to peer lists.
|
|
fn find_majority_size(size_map: &HashMap<u64, Vec<SocketAddr>>) -> (Option<u64>, usize) {
|
|
let mut majority_size = None;
|
|
let mut majority_count = 0;
|
|
|
|
for (&size, peers) in size_map {
|
|
let count = peers.len();
|
|
if count > majority_count {
|
|
majority_count = count;
|
|
majority_size = Some(size);
|
|
} else if count == majority_count {
|
|
// Tie between different sizes - ambiguous, fail
|
|
majority_size = None;
|
|
break;
|
|
}
|
|
}
|
|
|
|
(majority_size, majority_count)
|
|
}
|
|
|
|
/// Updates peer scores based on consensus participation.
|
|
fn update_peer_scores(
|
|
peers: &[SocketAddr],
|
|
peer_whitelist_scores: &mut HashMap<SocketAddr, usize>,
|
|
) {
|
|
for &peer in peers {
|
|
*peer_whitelist_scores.entry(peer).or_insert(0) += 1;
|
|
}
|
|
}
|
|
|
|
/// Creates a peer whitelist from scores, including peers with the highest scores.
|
|
fn create_peer_whitelist(peer_scores: HashMap<SocketAddr, usize>) -> Vec<SocketAddr> {
|
|
if peer_scores.is_empty() {
|
|
return Vec::new();
|
|
}
|
|
|
|
let mut peers: Vec<_> = peer_scores
|
|
.into_iter()
|
|
.filter_map(|(peer, score)| (score > 0).then_some((peer, score)))
|
|
.collect();
|
|
|
|
peers.sort_by_key(|(peer, score)| (Reverse(*score), *peer));
|
|
|
|
peers.into_iter().map(|(peer, _)| peer).collect()
|
|
}
|