//! Read node events from the local node. use std::{ fmt, path::{Path, PathBuf}, time, }; use radicle::{ Profile, node::{Event, Handle}, }; use crate::logger; /// Source of events from the local Radicle node. pub struct NodeEventSource { profile_path: PathBuf, events: Box>>, } impl NodeEventSource { /// Create a new source of node events, for a given Radicle /// profile. pub fn new(profile: &Profile) -> Result { let socket = profile.socket(); if !socket.exists() { return Err(NodeEventError::NoControlSocket(socket)); } let node = radicle::Node::new(socket.clone()); let source = match node.subscribe(time::Duration::MAX) { Ok(events) => Ok(Self { profile_path: profile.home.path().into(), events: Box::new(events.into_iter()), }), Err(err) => { logger::error("failed to subscribe to node events", &err); Err(NodeEventError::cannot_subscribe(&socket, err)) } }?; logger::node_event_source_created(&source); Ok(source) } /// Get the next node event from an event source, without /// filtering. This will block until there is an event, or until /// there will be no more events from this source, or there's an /// error. /// /// A closed or broken connection to the node is not an error, /// it's treated as end of file. pub fn node_event(&mut self) -> Result, NodeEventError> { if let Some(event) = self.events.next() { match event { Ok(event) => { logger::node_event_source_got_event(&event); Ok(Some(event)) } Err(radicle::node::Error::Io(err)) if err.kind() == std::io::ErrorKind::ConnectionReset => { logger::event_disconnected(); Ok(None) } Err(err) => { logger::error("error reading event from node", &err); Err(NodeEventError::node(err)) } } } else { logger::node_event_source_eof(self); Ok(None) } } } impl fmt::Debug for NodeEventSource { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "NodeEventSource", self.profile_path.display()) } } /// Kind of node event. #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum NodeEventKind { RefsFetched, RefsSynced, SeedDiscovered, SeedDropped, PeerConnected, LocalRefsAnnounced, InventoryAnnounced, RefsAnnounced, NodeAnnounced, UploadPack, CanonicalRefUpdated, Other, } impl From<&Event> for NodeEventKind { fn from(value: &Event) -> Self { match value { Event::RefsFetched { .. } => Self::RefsFetched, Event::RefsSynced { .. } => Self::RefsFetched, Event::SeedDiscovered { .. } => Self::SeedDiscovered, Event::SeedDropped { .. } => Self::SeedDropped, Event::PeerConnected { .. } => Self::PeerConnected, Event::LocalRefsAnnounced { .. } => Self::LocalRefsAnnounced, Event::InventoryAnnounced { .. } => Self::InventoryAnnounced, Event::RefsAnnounced { .. } => Self::RefsAnnounced, Event::NodeAnnounced { .. } => Self::NodeAnnounced, Event::UploadPack { .. } => Self::UploadPack, Event::CanonicalRefUpdated { .. } => Self::CanonicalRefUpdated, _ => Self::Other, } } } /// Possible errors from accessing the local Radicle node. #[derive(Debug, thiserror::Error)] pub enum NodeEventError { /// Node control socket does not exist. #[error("node control socket does not exist: {0}")] NoControlSocket(PathBuf), /// Can't subscribe to node events. #[error("failed to subscribe to node events on socket {0}")] CannotSubscribe( PathBuf, #[source] Box, ), /// Some error from getting an event from the node. #[error(transparent)] Node(#[from] Box), /// Connection to the node control socket broke. #[error("connection to the node control socket has been lost: can't continue")] BrokenConnection, } impl NodeEventError { fn cannot_subscribe(path: &Path, err: radicle::node::Error) -> Self { Self::CannotSubscribe(path.into(), Box::new(err)) } fn node(err: radicle::node::Error) -> Self { Self::Node(Box::new(err)) } }