Events: Add (re)connect success/fail events.

These should allow bots to hook up events to a variety of important connection events as required. This was primarily motivated by the user who raised dcb6ad9.

Although I really would have liked to squeeze in (finite) reconnection attempts with exponential backoff, so that automated repeat attempts could be neatly handled, `Config` was accidentally *not* made non-exhaustive. Adding this and its needed configuration would then be a breaking change. This should warn users about an accidentally dead connection, until the next version can be put forth.

src/driver/tasks/mod.rs

@@ -12,6 +12,7 @@ use super::{
     connection::{error::Error as ConnectionError, Connection},
     Config,
 };
+use crate::events::CoreContext;
 use flume::{Receiver, RecvError, Sender};
 use message::*;
 use tokio::runtime::Handle;
@@ -75,12 +76,21 @@ async fn runner(mut config: Config, rx: Receiver<CoreMessage>, tx: Sender<CoreMe
                     Ok(connection) => {
                         // Other side may not be listening: this is fine.
                         let _ = tx.send(Ok(()));
+
+                        let _ = interconnect
+                            .events
+                            .send(EventMessage::FireCoreEvent(CoreContext::DriverConnect));
+
                         Some(connection)
                     },
                     Err(why) => {
                         // See above.
                         let _ = tx.send(Err(why));
 
+                        let _ = interconnect.events.send(EventMessage::FireCoreEvent(
+                            CoreContext::DriverConnectFailed,
+                        ));
+
                         None
                     },
                 };
@@ -145,10 +155,19 @@ async fn runner(mut config: Config, rx: Receiver<CoreMessage>, tx: Sender<CoreMe
                             .await
                             .map_err(|e| {
                                 error!("Catastrophic connection failure. Stopping. {:?}", e);
+                                let _ = interconnect.events.send(EventMessage::FireCoreEvent(
+                                    CoreContext::DriverReconnectFailed,
+                                ));
                                 e
                             })
                             .ok();
                     }
+
+                    if connection.is_some() {
+                        let _ = interconnect
+                            .events
+                            .send(EventMessage::FireCoreEvent(CoreContext::DriverReconnect));
+                    }
                 }
             },
             Ok(CoreMessage::FullReconnect) =>
@@ -159,9 +178,18 @@ async fn runner(mut config: Config, rx: Receiver<CoreMessage>, tx: Sender<CoreMe
                         .await
                         .map_err(|e| {
                             error!("Catastrophic connection failure. Stopping. {:?}", e);
+                            let _ = interconnect.events.send(EventMessage::FireCoreEvent(
+                                CoreContext::DriverReconnectFailed,
+                            ));
                             e
                         })
                         .ok();
+
+                    if connection.is_some() {
+                        let _ = interconnect
+                            .events
+                            .send(EventMessage::FireCoreEvent(CoreContext::DriverReconnect));
+                    }
                 },
             Ok(CoreMessage::RebuildInterconnect) => {
                 interconnect.restart_volatile_internals();