p2p/network/scheduler_effectful/
p2p_network_scheduler_effectful_effects.rs

1use redux::ActionMeta;
2use std::net::SocketAddr;
3
4use crate::{MioCmd, P2pCryptoService, P2pMioService};
5
6use super::{super::*, *};
7
8impl P2pNetworkSchedulerEffectfulAction {
9    pub fn effects<Store, S>(self, _meta: &ActionMeta, store: &mut Store)
10    where
11        Store: crate::P2pStore<S>,
12        Store::Service: P2pMioService + P2pCryptoService,
13    {
14        match self {
15            P2pNetworkSchedulerEffectfulAction::InterfaceDetected { ip, port } => {
16                store
17                    .service()
18                    .send_mio_cmd(MioCmd::ListenOn(SocketAddr::new(ip, port)));
19            }
20            P2pNetworkSchedulerEffectfulAction::IncomingConnectionIsReady {
21                listener,
22                should_accept,
23            } => {
24                if should_accept {
25                    store.service().send_mio_cmd(MioCmd::Accept(listener));
26                } else {
27                    store.service().send_mio_cmd(MioCmd::Refuse(listener));
28                }
29            }
30            P2pNetworkSchedulerEffectfulAction::IncomingDidAccept { addr, .. } => {
31                let nonce = store.service().generate_random_nonce();
32                store.dispatch(P2pNetworkPnetAction::SetupNonce {
33                    addr,
34                    nonce: nonce.to_vec().into(),
35                    incoming: true,
36                });
37            }
38            P2pNetworkSchedulerEffectfulAction::OutgoingConnect { addr } => {
39                store.service().send_mio_cmd(MioCmd::Connect(addr));
40            }
41            P2pNetworkSchedulerEffectfulAction::OutgoingDidConnect { addr } => {
42                let nonce = store.service().generate_random_nonce();
43                store.dispatch(P2pNetworkPnetAction::SetupNonce {
44                    addr,
45                    nonce: nonce.to_vec().into(),
46                    incoming: false,
47                });
48            }
49            P2pNetworkSchedulerEffectfulAction::IncomingDataIsReady { addr, limit } => {
50                store.service().send_mio_cmd(MioCmd::Recv(addr, limit));
51            }
52            P2pNetworkSchedulerEffectfulAction::NoiseSelectDone { addr, incoming } => {
53                let ephemeral_sk = Sk::from_random(store.service().ephemeral_sk());
54                let static_sk = Sk::from_random(store.service().static_sk());
55                let static_pk = static_sk.pk();
56
57                let signature = store.service().sign_key(static_pk.0.as_bytes()).into();
58
59                store.dispatch(P2pNetworkNoiseAction::Init {
60                    addr,
61                    incoming,
62                    ephemeral_sk,
63                    static_sk,
64                    signature,
65                });
66            }
67            P2pNetworkSchedulerEffectfulAction::Disconnect { addr, reason } => {
68                store.service().send_mio_cmd(MioCmd::Disconnect(addr));
69                store.dispatch(P2pNetworkSchedulerAction::Disconnected { addr, reason });
70            }
71        }
72    }
73}