netapp/src/netapp.rs

448 lines
14 KiB
Rust
Raw Normal View History

2020-12-02 12:30:47 +00:00
use std::collections::HashMap;
use std::net::{IpAddr, SocketAddr};
2020-12-02 12:30:47 +00:00
use std::sync::{Arc, RwLock};
use log::{debug, error, info, trace, warn};
2020-12-02 12:30:47 +00:00
2021-10-12 15:59:46 +00:00
use arc_swap::ArcSwapOption;
use async_trait::async_trait;
2020-12-02 12:30:47 +00:00
2021-10-12 15:59:46 +00:00
use serde::{Deserialize, Serialize};
2020-12-02 12:30:47 +00:00
use sodiumoxide::crypto::auth;
use sodiumoxide::crypto::sign::ed25519;
use futures::stream::futures_unordered::FuturesUnordered;
use futures::stream::StreamExt;
2020-12-02 12:30:47 +00:00
use tokio::net::{TcpListener, TcpStream};
use tokio::select;
use tokio::sync::{mpsc, watch};
2020-12-02 12:30:47 +00:00
use crate::client::*;
2021-10-12 15:59:46 +00:00
use crate::endpoint::*;
2020-12-02 12:30:47 +00:00
use crate::error::*;
2022-07-21 15:34:53 +00:00
use crate::message::*;
use crate::server::*;
2020-12-02 12:30:47 +00:00
use crate::util::*;
/// Tag which is exchanged between client and server upon connection establishment
/// to check that they are running compatible versions of Netapp,
/// composed of 8 bytes for Netapp version and 8 bytes for client version
pub(crate) type VersionTag = [u8; 16];
/// Value of the Netapp version used in the version tag
pub(crate) const NETAPP_VERSION_TAG: u64 = 0x6e65746170700004; // netapp 0x0004
#[derive(Serialize, Deserialize, Debug, Clone)]
2021-10-12 15:59:46 +00:00
pub(crate) struct HelloMessage {
pub server_addr: Option<IpAddr>,
pub server_port: u16,
}
impl AutoSerialize for HelloMessage {}
2021-10-12 15:59:46 +00:00
impl Message for HelloMessage {
type Response = ();
}
2020-12-02 17:10:07 +00:00
2021-10-12 11:18:24 +00:00
type OnConnectHandler = Box<dyn Fn(NodeID, SocketAddr, bool) + Send + Sync>;
type OnDisconnectHandler = Box<dyn Fn(NodeID, bool) + Send + Sync>;
2020-12-02 19:12:24 +00:00
/// NetApp is the main class that handles incoming and outgoing connections.
///
2021-10-12 11:18:24 +00:00
/// NetApp can be used in a stand-alone fashion or together with a peering strategy.
/// If using it alone, you will want to set `on_connect` and `on_disconnect` events
/// in order to manage information about the current peer list.
2020-12-02 19:12:24 +00:00
///
/// It is generally not necessary to use NetApp stand-alone, as the provided full mesh
/// and RPS peering strategies take care of the most common use cases.
2020-12-02 12:30:47 +00:00
pub struct NetApp {
2020-12-12 18:27:18 +00:00
listen_params: ArcSwapOption<ListenParams>,
/// Version tag, 8 bytes for netapp version, 8 bytes for app version
pub version_tag: VersionTag,
/// Network secret key
2020-12-02 12:30:47 +00:00
pub netid: auth::Key,
/// Our peer ID
pub id: NodeID,
/// Private key associated with our peer ID
2020-12-02 12:30:47 +00:00
pub privkey: ed25519::SecretKey,
2020-12-02 19:12:24 +00:00
2021-10-12 15:59:46 +00:00
pub(crate) server_conns: RwLock<HashMap<NodeID, Arc<ServerConn>>>,
pub(crate) client_conns: RwLock<HashMap<NodeID, Arc<ClientConn>>>,
pub(crate) endpoints: RwLock<HashMap<String, DynEndpoint>>,
hello_endpoint: ArcSwapOption<Endpoint<HelloMessage, NetApp>>,
2021-10-12 11:18:24 +00:00
on_connected_handler: ArcSwapOption<OnConnectHandler>,
on_disconnected_handler: ArcSwapOption<OnDisconnectHandler>,
2020-12-02 12:30:47 +00:00
}
2020-12-12 18:27:18 +00:00
struct ListenParams {
listen_addr: SocketAddr,
public_addr: Option<IpAddr>,
}
2020-12-02 12:30:47 +00:00
impl NetApp {
2020-12-12 18:27:18 +00:00
/// Creates a new instance of NetApp, which can serve either as a full p2p node,
/// or just as a passive client. To upgrade to a full p2p node, spawn a listener
/// using `.listen()`
///
/// Our Peer ID is the public key associated to the secret key given here.
pub fn new(app_version_tag: u64, netid: auth::Key, privkey: ed25519::SecretKey) -> Arc<Self> {
let mut version_tag = [0u8; 16];
version_tag[0..8].copy_from_slice(&u64::to_be_bytes(NETAPP_VERSION_TAG)[..]);
version_tag[8..16].copy_from_slice(&u64::to_be_bytes(app_version_tag)[..]);
let id = privkey.public_key();
2020-12-02 12:30:47 +00:00
let netapp = Arc::new(Self {
2020-12-12 18:27:18 +00:00
listen_params: ArcSwapOption::new(None),
version_tag,
2020-12-02 12:30:47 +00:00
netid,
id,
2020-12-02 12:30:47 +00:00
privkey,
server_conns: RwLock::new(HashMap::new()),
client_conns: RwLock::new(HashMap::new()),
2021-10-12 15:59:46 +00:00
endpoints: RwLock::new(HashMap::new()),
hello_endpoint: ArcSwapOption::new(None),
2020-12-02 19:12:24 +00:00
on_connected_handler: ArcSwapOption::new(None),
on_disconnected_handler: ArcSwapOption::new(None),
2020-12-02 12:30:47 +00:00
});
2021-10-12 15:59:46 +00:00
netapp
.hello_endpoint
.swap(Some(netapp.endpoint("__netapp/netapp.rs/Hello".into())));
netapp
.hello_endpoint
.load_full()
.unwrap()
.set_handler(netapp.clone());
2020-12-02 12:30:47 +00:00
netapp
}
2020-12-02 19:12:24 +00:00
/// Set the handler to be called when a new connection (incoming or outgoing) has
/// been successfully established. Do not set this if using a peering strategy,
/// as the peering strategy will need to set this itself.
pub fn on_connected<F>(&self, handler: F)
where
F: Fn(NodeID, SocketAddr, bool) + Sized + Send + Sync + 'static,
{
self.on_connected_handler
.store(Some(Arc::new(Box::new(handler))));
2020-12-02 19:12:24 +00:00
}
/// Set the handler to be called when an existing connection (incoming or outgoing) has
/// been closed by either party. Do not set this if using a peering strategy,
/// as the peering strategy will need to set this itself.
pub fn on_disconnected<F>(&self, handler: F)
where
F: Fn(NodeID, bool) + Sized + Send + Sync + 'static,
{
self.on_disconnected_handler
.store(Some(Arc::new(Box::new(handler))));
2020-12-02 19:12:24 +00:00
}
2021-10-14 09:35:05 +00:00
/// Create a new endpoint with path `path`,
/// that handles messages of type `M`.
/// `H` is the type of the object that should handle requests
/// to this endpoint on the local node. If you don't want
/// to handle request on the local node (e.g. if this node
/// is only a client in the network), define the type `H`
/// to be `()`.
/// This function will panic if the endpoint has already been
/// created.
pub fn endpoint<M, H>(self: &Arc<Self>, path: String) -> Arc<Endpoint<M, H>>
2020-12-02 12:30:47 +00:00
where
M: Message + 'static,
2021-10-12 15:59:46 +00:00
H: EndpointHandler<M> + 'static,
2020-12-02 12:30:47 +00:00
{
2021-10-14 09:35:05 +00:00
let endpoint = Arc::new(Endpoint::<M, H>::new(self.clone(), path.clone()));
2021-10-12 15:59:46 +00:00
let endpoint_arc = EndpointArc(endpoint.clone());
if self
.endpoints
.write()
.unwrap()
2021-10-14 09:35:05 +00:00
.insert(path.clone(), Box::new(endpoint_arc))
2021-10-12 15:59:46 +00:00
.is_some()
{
2021-10-14 09:35:05 +00:00
panic!("Redefining endpoint: {}", path);
2021-10-12 15:59:46 +00:00
};
endpoint
2020-12-02 12:30:47 +00:00
}
2020-12-02 19:12:24 +00:00
/// Main listening process for our app. This future runs during the whole
/// run time of our application.
2020-12-12 18:27:18 +00:00
/// If this is not called, the NetApp instance remains a passive client.
pub async fn listen(
self: Arc<Self>,
listen_addr: SocketAddr,
public_addr: Option<IpAddr>,
mut must_exit: watch::Receiver<bool>,
) {
2020-12-12 18:27:18 +00:00
let listen_params = ListenParams {
listen_addr,
public_addr,
};
if self
.listen_params
.swap(Some(Arc::new(listen_params)))
.is_some()
{
error!("Trying to listen on NetApp but we're already listening!");
}
2020-12-12 18:27:18 +00:00
2021-10-12 11:07:34 +00:00
let listener = TcpListener::bind(listen_addr).await.unwrap();
2020-12-12 18:27:18 +00:00
info!("Listening on {}", listen_addr);
2020-12-02 12:30:47 +00:00
let (conn_in, mut conn_out) = mpsc::unbounded_channel();
let connection_collector = tokio::spawn(async move {
let mut collection = FuturesUnordered::new();
loop {
if collection.is_empty() {
match conn_out.recv().await {
Some(f) => collection.push(f),
None => break,
}
} else {
select! {
new_fut = conn_out.recv() => {
match new_fut {
Some(f) => collection.push(f),
None => break,
}
}
result = collection.next() => {
trace!("Collected connection: {:?}", result);
}
}
}
}
debug!("Collecting last open server connections.");
while let Some(conn_res) = collection.next().await {
trace!("Collected connection: {:?}", conn_res);
}
debug!("No more server connections to collect");
});
while !*must_exit.borrow_and_update() {
let (socket, peer_addr) = select! {
sockres = listener.accept() => {
match sockres {
Ok(x) => x,
Err(e) => {
warn!("Error in listener.accept: {}", e);
continue;
}
}
},
_ = must_exit.changed() => continue,
};
2020-12-02 12:30:47 +00:00
info!(
"Incoming connection from {}, negotiating handshake...",
peer_addr
2020-12-02 12:30:47 +00:00
);
let self2 = self.clone();
let must_exit2 = must_exit.clone();
conn_in
.send(tokio::spawn(async move {
ServerConn::run(self2, socket, must_exit2)
.await
.log_err("ServerConn::run");
}))
.log_err("Failed to send connection to connection collector");
2020-12-02 12:30:47 +00:00
}
drop(conn_in);
connection_collector
.await
.log_err("Failed to await for connection collector");
2020-12-02 12:30:47 +00:00
}
2021-10-21 10:14:19 +00:00
/// Drop all endpoint handlers, as well as handlers for connection/disconnection
/// events. (This disables the peering strategy)
///
/// Use this when terminating to break reference cycles
pub fn drop_all_handlers(&self) {
for (_, endpoint) in self.endpoints.read().unwrap().iter() {
endpoint.drop_handler();
}
2021-10-21 10:14:19 +00:00
self.on_connected_handler.store(None);
self.on_disconnected_handler.store(None);
}
2020-12-02 19:12:24 +00:00
/// Attempt to connect to a peer, given by its ip:port and its public key.
/// The public key will be checked during the secret handshake process.
/// This function returns once the connection has been established and a
/// successfull handshake was made. At this point we can send messages to
/// the other node with `Netapp::request`
pub async fn try_connect(self: Arc<Self>, ip: SocketAddr, id: NodeID) -> Result<(), Error> {
2020-12-02 19:12:24 +00:00
// Don't connect to ourself, we don't care
// but pretend we did
if id == self.id {
2020-12-02 17:10:07 +00:00
tokio::spawn(async move {
2020-12-02 19:12:24 +00:00
if let Some(h) = self.on_connected_handler.load().as_ref() {
h(id, ip, false);
2020-12-02 17:10:07 +00:00
}
});
return Ok(());
}
// Don't connect if already connected
if self.client_conns.read().unwrap().contains_key(&id) {
2020-12-02 12:30:47 +00:00
return Ok(());
}
2020-12-02 17:10:07 +00:00
2020-12-02 12:30:47 +00:00
let socket = TcpStream::connect(ip).await?;
info!("Connected to {}, negotiating handshake...", ip);
2021-10-12 11:18:24 +00:00
ClientConn::init(self, socket, id).await?;
2020-12-02 12:30:47 +00:00
Ok(())
}
2020-12-02 19:12:24 +00:00
/// Close the outgoing connection we have to a node specified by its public key,
/// if such a connection is currently open.
pub fn disconnect(self: &Arc<Self>, id: &NodeID) {
// If id is ourself, we're not supposed to have a connection open
if *id != self.id {
let conn = self.client_conns.write().unwrap().remove(id);
if let Some(c) = conn {
debug!(
"Closing connection to {} ({})",
2022-02-21 15:57:07 +00:00
hex::encode(&c.peer_id[..8]),
c.remote_addr
);
c.close();
} else {
return;
}
2020-12-02 17:10:07 +00:00
}
// call on_disconnected_handler immediately, since the connection
// was removed
// (if id == self.id, we pretend we disconnected)
let id = *id;
let self2 = self.clone();
tokio::spawn(async move {
if let Some(h) = self2.on_disconnected_handler.load().as_ref() {
h(id, false);
}
});
2020-12-02 12:30:47 +00:00
}
2020-12-02 19:12:24 +00:00
// Called from conn.rs when an incoming connection is successfully established
// Registers the connection in our list of connections
// Do not yet call the on_connected handler, because we don't know if the remote
// has an actual IP address and port we can call them back on.
// We will know this when they send a Hello message, which is handled below.
pub(crate) fn connected_as_server(&self, id: NodeID, conn: Arc<ServerConn>) {
2022-02-21 15:57:07 +00:00
info!(
"Accepted connection from {} at {}",
hex::encode(&id[..8]),
conn.remote_addr
);
2020-12-02 17:10:07 +00:00
2020-12-07 17:07:55 +00:00
self.server_conns.write().unwrap().insert(id, conn);
2020-12-02 12:30:47 +00:00
}
2020-12-02 19:12:24 +00:00
// Handle hello message from a client. This message is used for them to tell us
// that they are listening on a certain port number on which we can call them back.
// At this point we know they are a full network member, and not just a client,
// and we call the on_connected handler so that the peering strategy knows
// we have a new potential peer
2020-12-02 12:30:47 +00:00
2020-12-02 19:12:24 +00:00
// Called from conn.rs when an incoming connection is closed.
// We deregister the connection from server_conns and call the
// handler registered by on_disconnected
pub(crate) fn disconnected_as_server(&self, id: &NodeID, conn: Arc<ServerConn>) {
2022-02-21 15:57:07 +00:00
info!("Connection from {} closed", hex::encode(&id[..8]));
2020-12-02 17:10:07 +00:00
2020-12-02 12:30:47 +00:00
let mut conn_list = self.server_conns.write().unwrap();
if let Some(c) = conn_list.get(id) {
if Arc::ptr_eq(c, &conn) {
conn_list.remove(id);
2020-12-07 17:07:55 +00:00
drop(conn_list);
2020-12-02 12:30:47 +00:00
2020-12-07 17:07:55 +00:00
if let Some(h) = self.on_disconnected_handler.load().as_ref() {
h(conn.peer_id, true);
2020-12-07 17:07:55 +00:00
}
2020-12-02 12:30:47 +00:00
}
}
}
2020-12-02 19:12:24 +00:00
// Called from conn.rs when an outgoinc connection is successfully established.
// The connection is registered in self.client_conns, and the
// on_connected handler is called.
//
// Since we are ourself listening, we send them a Hello message so that
// they know on which port to call us back. (TODO: don't do this if we are
// just a simple client and not a full p2p node)
pub(crate) fn connected_as_client(&self, id: NodeID, conn: Arc<ClientConn>) {
2022-02-21 15:57:07 +00:00
info!("Connection established to {}", hex::encode(&id[..8]));
2020-12-02 17:10:07 +00:00
2020-12-02 12:30:47 +00:00
{
2020-12-07 17:07:55 +00:00
let old_c_opt = self.client_conns.write().unwrap().insert(id, conn.clone());
if let Some(old_c) = old_c_opt {
2020-12-02 12:30:47 +00:00
tokio::spawn(async move { old_c.close() });
}
}
2020-12-02 19:12:24 +00:00
if let Some(h) = self.on_connected_handler.load().as_ref() {
h(conn.peer_id, conn.remote_addr, false);
2020-12-02 12:30:47 +00:00
}
2020-12-12 18:27:18 +00:00
if let Some(lp) = self.listen_params.load_full() {
let server_addr = lp.public_addr;
let server_port = lp.listen_addr.port();
2021-10-12 15:59:46 +00:00
let hello_endpoint = self.hello_endpoint.load_full().unwrap();
2020-12-12 18:27:18 +00:00
tokio::spawn(async move {
2021-10-12 15:59:46 +00:00
hello_endpoint
.call(
&conn.peer_id,
&HelloMessage {
2021-10-12 15:59:46 +00:00
server_addr,
server_port,
},
PRIO_NORMAL,
)
.await
.log_err("Sending hello message");
2020-12-12 18:27:18 +00:00
});
}
2020-12-02 12:30:47 +00:00
}
2020-12-02 19:12:24 +00:00
// Called from conn.rs when an outgoinc connection is closed.
// The connection is removed from conn_list, and the on_disconnected handler
// is called.
pub(crate) fn disconnected_as_client(&self, id: &NodeID, conn: Arc<ClientConn>) {
2022-02-21 15:57:07 +00:00
info!("Connection to {} closed", hex::encode(&id[..8]));
2020-12-02 12:30:47 +00:00
let mut conn_list = self.client_conns.write().unwrap();
if let Some(c) = conn_list.get(id) {
if Arc::ptr_eq(c, &conn) {
conn_list.remove(id);
2020-12-07 17:07:55 +00:00
drop(conn_list);
2020-12-02 12:30:47 +00:00
2020-12-02 19:12:24 +00:00
if let Some(h) = self.on_disconnected_handler.load().as_ref() {
h(conn.peer_id, false);
2020-12-02 19:12:24 +00:00
}
2020-12-02 12:30:47 +00:00
}
}
// else case: happens if connection was removed in .disconnect()
// in which case on_disconnected_handler was already called
2020-12-02 12:30:47 +00:00
}
2021-10-12 15:59:46 +00:00
}
2020-12-02 17:10:07 +00:00
2021-10-12 15:59:46 +00:00
#[async_trait]
impl EndpointHandler<HelloMessage> for NetApp {
async fn handle(self: &Arc<Self>, msg: &HelloMessage, from: NodeID) {
2022-02-21 15:57:07 +00:00
debug!("Hello from {:?}: {:?}", hex::encode(&from[..8]), msg);
2021-10-12 15:59:46 +00:00
if let Some(h) = self.on_connected_handler.load().as_ref() {
if let Some(c) = self.server_conns.read().unwrap().get(&from) {
let remote_ip = msg.server_addr.unwrap_or_else(|| c.remote_addr.ip());
let remote_addr = SocketAddr::new(remote_ip, msg.server_port);
h(from, remote_addr, true);
2020-12-02 17:10:07 +00:00
}
}
}
2020-12-02 12:30:47 +00:00
}