Struct holochain::sweettest::SweetConductorHandle

pub struct SweetConductorHandle(_);

A wrapper around ConductorHandle with more convenient methods for testing and a cleanup drop

Implementations

impl SweetConductorHandle

pub async fn call<I, O, F>(&self, zome: &SweetZome, fn_name: F, payload: I) -> Owhere
    FunctionName: From<F>,
    I: Serialize + Debug,
    O: DeserializeOwned + Debug,

Make a zome call to a Cell, as if that Cell were the caller. Most common case. No capability is necessary, since the authorship capability is automatically granted.

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,
    }
}

pub async fn call_fallible<I, O, F>(
    &self,
    zome: &SweetZome,
    fn_name: F,
    payload: I
) -> ConductorApiResult<O>where
    FunctionName: From<F>,
    I: Serialize + Debug,
    O: DeserializeOwned + Debug,

Like call, but without the unwrap

Examples found in repository

src/sweettest/sweet_conductor_handle.rs (line 23)

    pub async fn call<I, O, F>(&self, zome: &SweetZome, fn_name: F, payload: I) -> O
    where
        FunctionName: From<F>,
        I: serde::Serialize + std::fmt::Debug,
        O: serde::de::DeserializeOwned + std::fmt::Debug,
    {
        self.call_fallible(zome, fn_name, payload).await.unwrap()
    }

pub async fn call_from<I, O, F>(
    &self,
    provenance: &AgentPubKey,
    cap_secret: Option<CapSecret>,
    zome: &SweetZome,
    fn_name: F,
    payload: I
) -> Owhere
    FunctionName: From<F>,
    I: Serialize + Debug,
    O: DeserializeOwned + Debug,

Make a zome call to a Cell, as if some other Cell were the caller. More general case. Can optionally provide a capability.

pub async fn call_from_fallible<I, O, F>(
    &self,
    provenance: &AgentPubKey,
    cap_secret: Option<CapSecret>,
    zome: &SweetZome,
    fn_name: F,
    payload: I
) -> ConductorApiResult<O>where
    FunctionName: From<F>,
    I: Serialize + Debug,
    O: DeserializeOwned + Debug,

Like call_from, but without the unwrap

Examples found in repository

src/sweettest/sweet_conductor_handle.rs (line 38)

    pub async fn call_fallible<I, O, F>(
        &self,
        zome: &SweetZome,
        fn_name: F,
        payload: I,
    ) -> ConductorApiResult<O>
    where
        FunctionName: From<F>,
        I: serde::Serialize + std::fmt::Debug,
        O: serde::de::DeserializeOwned + std::fmt::Debug,
    {
        self.call_from_fallible(zome.cell_id().agent_pubkey(), None, zome, fn_name, payload)
            .await
    }
    /// Make a zome call to a Cell, as if some other Cell were the caller. More general case.
    /// Can optionally provide a capability.
    pub async fn call_from<I, O, F>(
        &self,
        provenance: &AgentPubKey,
        cap_secret: Option<CapSecret>,
        zome: &SweetZome,
        fn_name: F,
        payload: I,
    ) -> O
    where
        FunctionName: From<F>,
        I: Serialize + std::fmt::Debug,
        O: serde::de::DeserializeOwned + std::fmt::Debug,
    {
        self.call_from_fallible(provenance, cap_secret, zome, fn_name, payload)
            .await
            .unwrap()
    }

pub async fn signal_stream(&self) -> impl Stream<Item = Signal>

Get a stream of all Signals emitted since the time of this function call.

pub async fn shutdown_and_wait(&self)

Manually await shutting down the conductor. Conductors are already cleaned up on drop but this is useful if you need to know when it’s finished cleaning up.

Examples found in repository

src/sweettest/sweet_conductor.rs (line 399)

    pub async fn shutdown(&mut self) {
        if let Some(handle) = self.handle.take() {
            handle.shutdown_and_wait().await;
        } else {
            panic!("Attempted to shutdown conductor which was already shutdown");
        }
    }

Trait Implementations

impl AsRef<Arc<Conductor>> for SweetConductorHandle

fn as_ref(&self) -> &ConductorHandle

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<SweetConductorHandle> for SweetConductor

fn as_ref(&self) -> &SweetConductorHandle

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<Arc<Conductor>> for SweetConductorHandle

fn borrow(&self) -> &ConductorHandle

Immutably borrows from an owned value.

impl Borrow<SweetConductorHandle> for SweetConductor

fn borrow(&self) -> &SweetConductorHandle

Immutably borrows from an owned value.

impl Deref for SweetConductorHandle

type Target = Arc<Conductor>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl From<Arc<Conductor>> for SweetConductorHandle

fn from(original: ConductorHandle) -> SweetConductorHandle

Converts to this type from the input type.