tatami 0.1.2

A library for creating satellites and interacting with Tatami protocols.
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

use std::fmt::Debug;

#[cfg(feature = "mdns")]
use libp2p::mdns::MdnsEvent;
use libp2p::{
	gossipsub::{GossipsubEvent, GossipsubMessage},
	kad::KademliaEvent,
	swarm::SwarmEvent,
};
#[cfg(feature = "mdns")]
use tracing::trace;
use tracing::{info, warn};

use crate::{
	satellite::{
		message::{Message, PeerMessage},
		TatamiEvent,
	},
	swarm::event::SatelliteSwamEvent,
	Satellite, TatamiError,
};

impl Satellite {
	/// The single function to parse and manage every Swarm event
	pub fn handle_swarm_event<T: Debug>(
		&mut self,
		event: SwarmEvent<SatelliteSwamEvent, T>,
	) -> Result<(), TatamiError> {
		match event {
			// Whenever a connection is established
			SwarmEvent::ConnectionEstablished { peer_id, .. } => {
				info!("Connection established with {}", peer_id);
				self.event_sender
					.send(TatamiEvent::ConnectionEstablished(peer_id))
					.or(Err(TatamiError::Breakdown))?;
			}
			// Whenever a connection is closed
			SwarmEvent::ConnectionClosed { peer_id, cause, .. } => {
				info!("Connection closed with {}", peer_id);
				warn!("Reason: {:#?}", cause);
				self.event_sender
					.send(TatamiEvent::ConnectionClosed(peer_id))
					.or(Err(TatamiError::Breakdown))?;
			}
			SwarmEvent::NewListenAddr { address, .. } => {
				info!("Now listening on {}", address);
				self.event_sender
					.send(TatamiEvent::NewListenAddress(address))
					.or(Err(TatamiError::Breakdown))?;
			}
			#[cfg(feature = "mdns")]
			SwarmEvent::Behaviour(SatelliteSwamEvent::Mdns(MdnsEvent::Discovered(discovered))) => {
				trace!("Discovered {:#?}", discovered);
				for (peer_id, multiaddr) in discovered {
					if self.config.mdns_config.auto_register {
						info!("Automatically registering {}", peer_id);
						self.add_address(&peer_id, multiaddr);
					}
				}
			}
			SwarmEvent::Behaviour(SatelliteSwamEvent::Kademlia(
				KademliaEvent::RoutingUpdated { peer, .. },
			)) => {
				info!("Satellite can see {}", peer);
				if self.config.auto_connect && !self.is_connected(&peer) {
					info!("Automatically dialling {}", peer);
					self.dial_peer(peer)?;
				}
			}
			SwarmEvent::Behaviour(SatelliteSwamEvent::GossipSub(GossipsubEvent::Message {
				message: GossipsubMessage { data, .. },
				..
			})) => {
				let message: Message =
					serde_json::from_slice(&data).or(Err(TatamiError::Generic))?;
				info!("Received message {:#?}", message);
				// Check the message
				if message.verify()? {
					let peer_message = PeerMessage {
						peer: message.source()?,
						payload: message.payload,
					};
					self.event_sender
						.send(TatamiEvent::MessageReceived(peer_message))
						.or(Err(TatamiError::Breakdown))?;
				}
			}
			// An undiagnosed event occurs
			_ => {
				info!("Undiagnosed Event: {:#?}", event);
				self.event_sender
					.send(TatamiEvent::UndiagnosedEvent)
					.or(Err(TatamiError::Breakdown))?;
			}
		}
		Ok(())
	}
}