fuzzytags-sim/src/parties.rs

use crate::server::SimulatedServer;
use fuzzytags::FuzzySecretKey;
use rand::distributions::Distribution;
use rand::Rng;
use rand_distr::num_traits::ToPrimitive;
use tracing::event;
use tracing::span;
use tracing::Level;

pub struct SimulatedParties {
    parties: Vec<FuzzySecretKey>,
}

impl SimulatedParties {
    pub fn new_simulation(num_parties: usize, gamma: usize) -> SimulatedParties {
        let mut parties = vec![];
        for _p in 0..num_parties {
            let key = FuzzySecretKey::generate(gamma);
            parties.push(key);
        }
        SimulatedParties { parties }
    }

    pub fn register_with_server<R>(&self, server: &mut SimulatedServer, rng: &mut R, min_p: usize, max_p: usize)
    where
        R: Rng,
    {
        let span = span!(Level::TRACE, "register_with_server");
        let _enter = span.enter();
        for party in self.parties.iter() {
            let n = rng.gen_range(min_p..max_p);
            let span = span!(Level::TRACE, "{register}", party = party.public_key().id().as_str());
            let _enter = span.enter();
            let detection_key = party.extract(n);
            event!(Level::TRACE, "create detection key {detection_key}", detection_key = detection_key.id().as_str());
            event!(Level::TRACE, "register with server");
            server.register_key(&detection_key, &party.public_key());
        }
    }

    pub fn sample_traffic<R, D>(&self, server: &mut SimulatedServer, rng: &mut R, distribution: D)
    where
        D: Distribution<f64>,
        R: Rng,
    {
        let span = span!(Level::TRACE, "sample_traffic");
        let _enter = span.enter();
        let v = distribution.sample(rng).to_u16().unwrap();
        let receiver = rng.gen_range(0..self.parties.len());
        let receiver_public_key = self.parties.get(receiver).unwrap().public_key();

        let span = span!(Level::TRACE, "{party}", party = receiver_public_key.id().as_str());
        let _enter = span.enter();
        for _i in 0..v {
            let tag = receiver_public_key.generate_tag();
            event!(Level::TRACE, "message sent to {tag}", tag = tag.to_string());
            server.add_message(tag);
        }
    }
}