holochain 0.7.0-dev.20

Holochain, a framework for distributed applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

//! The queue consumer for the countersigning workflow.

use super::*;
#[cfg(feature = "unstable-countersigning")]
use crate::core::workflow::countersigning_workflow::countersigning_workflow;
use tracing::*;

/// Spawn the QueueConsumer for the countersigning workflow
#[instrument(skip_all)]
#[allow(unused_variables)]
pub(crate) fn spawn_countersigning_consumer(
    space: Space,
    workspace: Arc<CountersigningWorkspace>,
    cell_id: CellId,
    conductor: ConductorHandle,
    integration_trigger: TriggerSender,
    publish_trigger: TriggerSender,
) -> TriggerSender {
    let (tx, rx) = TriggerSender::new();

    let self_trigger = tx.clone();
    queue_consumer_cell_bound(
        "countersigning_consumer",
        cell_id.clone(),
        conductor.task_manager(),
        (tx.clone(), rx),
        #[cfg(not(feature = "unstable-countersigning"))]
        move || async { WorkflowResult::Ok(WorkComplete::Complete) },
        #[cfg(feature = "unstable-countersigning")]
        move || {
            countersigning_workflow_fn(
                space.clone(),
                workspace.clone(),
                cell_id.clone(),
                conductor.clone(),
                self_trigger.clone(),
                integration_trigger.clone(),
                publish_trigger.clone(),
            )
        },
    );

    tx
}

#[cfg(feature = "unstable-countersigning")]
async fn countersigning_workflow_fn(
    space: Space,
    workspace: Arc<CountersigningWorkspace>,
    cell_id: CellId,
    conductor: ConductorHandle,
    self_trigger: TriggerSender,
    integration_trigger: TriggerSender,
    publish_trigger: TriggerSender,
) -> WorkflowResult<WorkComplete> {
    let signal_tx = conductor
        .get_signal_tx(&cell_id)
        .await
        .map_err(WorkflowError::other)?;

    let cell = conductor
        .cell_by_id(&cell_id)
        .await
        .map_err(WorkflowError::other)?;
    let cell_network = cell.holochain_p2p_dna();

    let keystore = conductor.keystore().clone();

    countersigning_workflow(
        space.clone(),
        workspace,
        Arc::new(cell_network.clone()),
        keystore,
        cell_id.clone(),
        signal_tx,
        self_trigger.clone(),
        integration_trigger.clone(),
        publish_trigger.clone(),
    )
    .await
}