Struct holochain::sweettest::SweetCell

pub struct SweetCell { /* private fields */ }

A reference to a Cell created by a SweetConductor installation function. It has very concise methods for calling a zome on this cell

Implementations

impl SweetCell

pub fn cell_id(&self) -> &CellId

Accessor for CellId

pub fn authored_db(&self) -> &DbWrite<DbKindAuthored>

Get the authored environment for this cell

Examples found in repository

src/test_utils/network_simulation.rs (line 427)

async fn create_test_data(
    num_agents: usize,
    approx_num_ops_held: usize,
    dna_file: DnaFile,
    integrity_uuid: String,
    coordinator_uuid: String,
) -> GeneratedData {
    let coverage = ((50.0 / num_agents as f64) * 2.0).clamp(0.0, 1.0);
    let num_storage_buckets = (1.0 / coverage).round() as u32;
    let bucket_size = u32::MAX / num_storage_buckets;
    let buckets = (0..num_storage_buckets)
        .map(|i| DhtArcRange::from_bounds(i * bucket_size, i * bucket_size + bucket_size))
        .collect::<Vec<_>>();
    let mut bucket_counts = vec![0; buckets.len()];
    let mut entries = Vec::with_capacity(buckets.len() * approx_num_ops_held);
    let rng = rand::thread_rng();
    let mut rand_entry = rng.sample_iter(&Standard);
    let rand_entry = rand_entry.by_ref();
    let start = std::time::Instant::now();
    loop {
        let d: Vec<u8> = rand_entry.take(10).collect();
        let d = UnsafeBytes::from(d);
        let entry = Entry::app(d.try_into().unwrap()).unwrap();
        let hash = EntryHash::with_data_sync(&entry);
        let loc = hash.get_loc();
        if let Some(index) = buckets.iter().position(|b| b.contains(&loc)) {
            if bucket_counts[index] < approx_num_ops_held * 100 {
                entries.push(entry);
                bucket_counts[index] += 1;
            }
        }
        if bucket_counts
            .iter()
            .all(|&c| c >= approx_num_ops_held * 100)
        {
            break;
        }
    }
    dbg!(bucket_counts);
    dbg!(start.elapsed());

    let mut tuning =
        kitsune_p2p_types::config::tuning_params_struct::KitsuneP2pTuningParams::default();
    tuning.gossip_strategy = "none".to_string();
    tuning.disable_publish = true;

    let mut network = KitsuneP2pConfig::default();
    network.tuning_params = Arc::new(tuning);
    let config = ConductorConfig {
        network: Some(network),
        ..Default::default()
    };
    let mut conductor = SweetConductor::from_config(config).await;
    let mut agents = Vec::new();
    dbg!("generating agents");
    for i in 0..num_agents {
        eprintln!("generating agent {}", i);
        let agent = conductor
            .keystore()
            .clone()
            .new_sign_keypair_random()
            .await
            .unwrap();
        agents.push(agent);
    }

    dbg!("Installing apps");

    let apps = conductor
        .setup_app_for_agents("app", &agents, &[dna_file.clone()])
        .await
        .unwrap();

    let cells = apps.cells_flattened();
    let mut entries = entries.into_iter();
    let entries = entries.by_ref();
    for (i, cell) in cells.iter().enumerate() {
        eprintln!("Calling {}", i);
        let e = entries.take(approx_num_ops_held).collect::<Vec<_>>();
        conductor
            .call::<_, (), _>(&cell.zome("zome1"), "create_many", e)
            .await;
    }
    let mut authored = HashMap::new();
    let mut ops = HashMap::new();
    for (i, cell) in cells.iter().enumerate() {
        eprintln!("Extracting data {}", i);
        let db = cell.authored_db().clone();
        let data = fresh_reader_test(db, |mut txn| {
            get_authored_ops(&mut txn, cell.agent_pubkey())
        });
        let hashes = data.keys().cloned().collect::<Vec<_>>();
        authored.insert(Arc::new(cell.agent_pubkey().clone()), hashes);
        ops.extend(data);
    }
    dbg!("Getting agent info");
    let peer_data = conductor.get_agent_infos(None).await.unwrap();
    dbg!("Done");
    GeneratedData {
        integrity_uuid,
        coordinator_uuid,
        peer_data,
        authored,
        ops,
    }
}

pub fn dht_db(&self) -> &DbWrite<DbKindDht>

Get the dht environment for this cell

pub fn agent_pubkey(&self) -> &AgentPubKey

Accessor for AgentPubKey

Examples found in repository

src/sweettest/sweet_app.rs (line 19)

    pub(super) fn new(installed_app_id: InstalledAppId, cells: Vec<SweetCell>) -> Self {
        // Ensure that all Agents are the same
        assert!(
            cells.iter().map(|c| c.agent_pubkey()).dedup().count() == 1,
            "Agent key differs across Cells in this app"
        );
        Self {
            installed_app_id,
            cells,
        }
    }

    /// Accessor
    pub fn installed_app_id(&self) -> &InstalledAppId {
        &self.installed_app_id
    }

    /// Accessor
    pub fn cells(&self) -> &Vec<SweetCell> {
        &self.cells
    }

    /// Accessor
    pub fn into_cells(self) -> Vec<SweetCell> {
        self.cells
    }

    /// Returns the AgentPubKey associated with this app.
    /// All Cells in this app will have the same Agent, so we just return the first.
    pub fn agent(&self) -> &AgentPubKey {
        self.cells[0].agent_pubkey()
    }

src/test_utils/network_simulation.rs (line 429)

async fn create_test_data(
    num_agents: usize,
    approx_num_ops_held: usize,
    dna_file: DnaFile,
    integrity_uuid: String,
    coordinator_uuid: String,
) -> GeneratedData {
    let coverage = ((50.0 / num_agents as f64) * 2.0).clamp(0.0, 1.0);
    let num_storage_buckets = (1.0 / coverage).round() as u32;
    let bucket_size = u32::MAX / num_storage_buckets;
    let buckets = (0..num_storage_buckets)
        .map(|i| DhtArcRange::from_bounds(i * bucket_size, i * bucket_size + bucket_size))
        .collect::<Vec<_>>();
    let mut bucket_counts = vec![0; buckets.len()];
    let mut entries = Vec::with_capacity(buckets.len() * approx_num_ops_held);
    let rng = rand::thread_rng();
    let mut rand_entry = rng.sample_iter(&Standard);
    let rand_entry = rand_entry.by_ref();
    let start = std::time::Instant::now();
    loop {
        let d: Vec<u8> = rand_entry.take(10).collect();
        let d = UnsafeBytes::from(d);
        let entry = Entry::app(d.try_into().unwrap()).unwrap();
        let hash = EntryHash::with_data_sync(&entry);
        let loc = hash.get_loc();
        if let Some(index) = buckets.iter().position(|b| b.contains(&loc)) {
            if bucket_counts[index] < approx_num_ops_held * 100 {
                entries.push(entry);
                bucket_counts[index] += 1;
            }
        }
        if bucket_counts
            .iter()
            .all(|&c| c >= approx_num_ops_held * 100)
        {
            break;
        }
    }
    dbg!(bucket_counts);
    dbg!(start.elapsed());

    let mut tuning =
        kitsune_p2p_types::config::tuning_params_struct::KitsuneP2pTuningParams::default();
    tuning.gossip_strategy = "none".to_string();
    tuning.disable_publish = true;

    let mut network = KitsuneP2pConfig::default();
    network.tuning_params = Arc::new(tuning);
    let config = ConductorConfig {
        network: Some(network),
        ..Default::default()
    };
    let mut conductor = SweetConductor::from_config(config).await;
    let mut agents = Vec::new();
    dbg!("generating agents");
    for i in 0..num_agents {
        eprintln!("generating agent {}", i);
        let agent = conductor
            .keystore()
            .clone()
            .new_sign_keypair_random()
            .await
            .unwrap();
        agents.push(agent);
    }

    dbg!("Installing apps");

    let apps = conductor
        .setup_app_for_agents("app", &agents, &[dna_file.clone()])
        .await
        .unwrap();

    let cells = apps.cells_flattened();
    let mut entries = entries.into_iter();
    let entries = entries.by_ref();
    for (i, cell) in cells.iter().enumerate() {
        eprintln!("Calling {}", i);
        let e = entries.take(approx_num_ops_held).collect::<Vec<_>>();
        conductor
            .call::<_, (), _>(&cell.zome("zome1"), "create_many", e)
            .await;
    }
    let mut authored = HashMap::new();
    let mut ops = HashMap::new();
    for (i, cell) in cells.iter().enumerate() {
        eprintln!("Extracting data {}", i);
        let db = cell.authored_db().clone();
        let data = fresh_reader_test(db, |mut txn| {
            get_authored_ops(&mut txn, cell.agent_pubkey())
        });
        let hashes = data.keys().cloned().collect::<Vec<_>>();
        authored.insert(Arc::new(cell.agent_pubkey().clone()), hashes);
        ops.extend(data);
    }
    dbg!("Getting agent info");
    let peer_data = conductor.get_agent_infos(None).await.unwrap();
    dbg!("Done");
    GeneratedData {
        integrity_uuid,
        coordinator_uuid,
        peer_data,
        authored,
        ops,
    }
}

pub fn dna_hash(&self) -> &DnaHash

Accessor for DnaHash

pub fn zome<Z: Into<ZomeName>>(&self, zome_name: Z) -> SweetZome

Get a SweetZome with the given name

Examples found in repository

src/test_utils/network_simulation.rs (line 420)

async fn create_test_data(
    num_agents: usize,
    approx_num_ops_held: usize,
    dna_file: DnaFile,
    integrity_uuid: String,
    coordinator_uuid: String,
) -> GeneratedData {
    let coverage = ((50.0 / num_agents as f64) * 2.0).clamp(0.0, 1.0);
    let num_storage_buckets = (1.0 / coverage).round() as u32;
    let bucket_size = u32::MAX / num_storage_buckets;
    let buckets = (0..num_storage_buckets)
        .map(|i| DhtArcRange::from_bounds(i * bucket_size, i * bucket_size + bucket_size))
        .collect::<Vec<_>>();
    let mut bucket_counts = vec![0; buckets.len()];
    let mut entries = Vec::with_capacity(buckets.len() * approx_num_ops_held);
    let rng = rand::thread_rng();
    let mut rand_entry = rng.sample_iter(&Standard);
    let rand_entry = rand_entry.by_ref();
    let start = std::time::Instant::now();
    loop {
        let d: Vec<u8> = rand_entry.take(10).collect();
        let d = UnsafeBytes::from(d);
        let entry = Entry::app(d.try_into().unwrap()).unwrap();
        let hash = EntryHash::with_data_sync(&entry);
        let loc = hash.get_loc();
        if let Some(index) = buckets.iter().position(|b| b.contains(&loc)) {
            if bucket_counts[index] < approx_num_ops_held * 100 {
                entries.push(entry);
                bucket_counts[index] += 1;
            }
        }
        if bucket_counts
            .iter()
            .all(|&c| c >= approx_num_ops_held * 100)
        {
            break;
        }
    }
    dbg!(bucket_counts);
    dbg!(start.elapsed());

    let mut tuning =
        kitsune_p2p_types::config::tuning_params_struct::KitsuneP2pTuningParams::default();
    tuning.gossip_strategy = "none".to_string();
    tuning.disable_publish = true;

    let mut network = KitsuneP2pConfig::default();
    network.tuning_params = Arc::new(tuning);
    let config = ConductorConfig {
        network: Some(network),
        ..Default::default()
    };
    let mut conductor = SweetConductor::from_config(config).await;
    let mut agents = Vec::new();
    dbg!("generating agents");
    for i in 0..num_agents {
        eprintln!("generating agent {}", i);
        let agent = conductor
            .keystore()
            .clone()
            .new_sign_keypair_random()
            .await
            .unwrap();
        agents.push(agent);
    }

    dbg!("Installing apps");

    let apps = conductor
        .setup_app_for_agents("app", &agents, &[dna_file.clone()])
        .await
        .unwrap();

    let cells = apps.cells_flattened();
    let mut entries = entries.into_iter();
    let entries = entries.by_ref();
    for (i, cell) in cells.iter().enumerate() {
        eprintln!("Calling {}", i);
        let e = entries.take(approx_num_ops_held).collect::<Vec<_>>();
        conductor
            .call::<_, (), _>(&cell.zome("zome1"), "create_many", e)
            .await;
    }
    let mut authored = HashMap::new();
    let mut ops = HashMap::new();
    for (i, cell) in cells.iter().enumerate() {
        eprintln!("Extracting data {}", i);
        let db = cell.authored_db().clone();
        let data = fresh_reader_test(db, |mut txn| {
            get_authored_ops(&mut txn, cell.agent_pubkey())
        });
        let hashes = data.keys().cloned().collect::<Vec<_>>();
        authored.insert(Arc::new(cell.agent_pubkey().clone()), hashes);
        ops.extend(data);
    }
    dbg!("Getting agent info");
    let peer_data = conductor.get_agent_infos(None).await.unwrap();
    dbg!("Done");
    GeneratedData {
        integrity_uuid,
        coordinator_uuid,
        peer_data,
        authored,
        ops,
    }
}

Trait Implementations

impl Clone for SweetCell

fn clone(&self) -> SweetCell

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SweetCell

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.