locutus-dev 0.0.3

Locutus P2P development tools
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use locutus_core::ClientId;
use locutus_stdlib::api::{ClientRequest, ContractRequest, ContractResponse, HostResponse};

use crate::{CommandReceiver, DynError};

use super::{state::AppState, LocalNodeCliConfig};

pub(super) async fn wasm_runtime(
    _config: LocalNodeCliConfig,
    mut command_receiver: CommandReceiver,
    mut app: AppState,
) -> Result<(), DynError> {
    loop {
        let req = command_receiver.recv().await;
        let dc = execute_command(req.ok_or("channel closed")?, &mut app).await?;
        if dc {
            break;
        }
    }
    Ok(())
}

async fn execute_command(
    req: ClientRequest<'static>,
    app: &mut AppState,
) -> Result<bool, DynError> {
    let node = &mut *app.local_node.write().await;
    match req {
        ClientRequest::ContractOp(op) => match op {
            req @ ContractRequest::Put { .. } => {
                match node.handle_request(ClientId::FIRST, req.into(), None).await {
                    Ok(HostResponse::ContractResponse(ContractResponse::PutResponse { key })) => {
                        println!("valid put for {key}");
                    }
                    Err(err) => {
                        println!("error: {err}");
                    }
                    _ => unreachable!(),
                }
            }
            req @ ContractRequest::Update { .. } => {
                match node.handle_request(ClientId::FIRST, req.into(), None).await {
                    Ok(HostResponse::ContractResponse(ContractResponse::UpdateResponse {
                        key,
                        summary,
                    })) => {
                        println!("valid update for {key}, state summary:");
                        app.printout_deser(summary.as_ref())?;
                    }
                    Err(err) => {
                        println!("error: {err}");
                    }
                    _ => unreachable!(),
                }
            }
            ContractRequest::Get {
                key,
                fetch_contract: contract,
            } => {
                match node
                    .handle_request(
                        ClientId::FIRST,
                        ContractRequest::Get {
                            key: key.clone(),
                            fetch_contract: contract,
                        }
                        .into(),
                        None,
                    )
                    .await
                {
                    Ok(HostResponse::ContractResponse(ContractResponse::GetResponse {
                        state,
                        ..
                    })) => {
                        println!("current state for {key}:");
                        app.printout_deser(state.as_ref())?;
                        todo!()
                    }
                    Err(err) => {
                        println!("error: {err}");
                    }
                    _ => unreachable!(),
                }
            }
            _ => unreachable!(),
        },
        ClientRequest::ComponentOp(op) => {
            match node.handle_request(ClientId::FIRST, op.into(), None).await {
                Ok(_res) => todo!(),
                Err(either::Either::Left(err)) => {
                    println!("error: {err}");
                }
                Err(either::Either::Right(err)) => {
                    println!("error: {err}");
                }
            }
        }
        ClientRequest::Disconnect { .. } => return Ok(true),
        ClientRequest::GenerateRandData { .. } => todo!("FIXME"),
    }
    Ok(false)
}