plexor-codec-serde-postcard 0.1.0-alpha.2

Postcard codec implementation for the Plexo distributed system architecture using Serde.
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

use plexor_core::neuron::{Neuron, NeuronImpl};
use plexor_core::plexus::Plexus;
use plexor_core::axon::{Axon, AxonImpl};
use plexor_core::reactant::{Reactant, ReactantError};
use plexor_core::payload::Payload;
use plexor_core::erasure::reactant::ReactantErased;
use plexor_core::namespace::NamespaceImpl;
use plexor_core::ganglion::{Ganglion, GanglionInternal};
use plexor_codec_serde_postcard::SerdePostcardCodec;
use std::sync::Arc;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug, Clone)]
struct HelloMessage {
    target: String,
    count: u32,
}

#[derive(Clone)]
struct HelloReactant;

impl Reactant<HelloMessage, SerdePostcardCodec> for HelloReactant {
    fn react(&self, payload: Arc<Payload<HelloMessage, SerdePostcardCodec>>) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), ReactantError>> + Send + 'static>> {
        Box::pin(async move {
            println!("Reactant received: Hello {}, count is {}", payload.value.target, payload.value.count);
            Ok(())
        })
    }
    fn erase(self: Box<Self>) -> Arc<dyn ReactantErased + Send + Sync + 'static> {
        plexor_core::erasure::reactant::erase_reactant(self)
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. Define Identity
    let ns = Arc::new(NamespaceImpl { delimiter: ".".into(), parts: vec!["example", "hello"] });
    let neuron = NeuronImpl::<HelloMessage, SerdePostcardCodec>::new_arc(ns);

    // 2. Create Plexus
    let plexus_arc = Plexus::new_shared(vec![], vec![]).await;
    
    // 3. Register Reactant
    {
        let mut p = plexus_arc.lock().await;
        p.adapt(neuron.clone()).await?;
        p.react(neuron.name(), vec![Box::new(HelloReactant).erase()], vec![]).await?;
    }
    
    // 4. Fire Axon
    let mut axon = AxonImpl::new(neuron, plexus_arc);
    axon.transmit(HelloMessage { target: "World".into(), count: 42 }).await?;

    Ok(())
}