Remove stopping (#82)

* Remove stopping and repurpose KeepRunning

* Fix build - logic will be fixed in #83

* Change stop_all behaviour - in line with stop_self

Previously, stop_all would immediately disconnect the address. However, stop_self done on every actor would actually not do this in one case - if there were a free-floating (not executing an actor event loop) Context. This change brings stop_all in line with stop_self.

* Fmt + document more breaking changes

* merge oversight

BREAKING-CHANGES.md

@@ -1,17 +1,19 @@
 # Breaking Changes by Version
 
-## Unreleased
-
-- `Context::notify_interval` and `Context::notify_after` are now subject to back-pressure.
-  These aren't API breaking but a semantic changes.
-
 ## 0.6.0
 
 - Sealed `RefCounter`, `MessageChannel`, and `MessageSink` traits
 - `AddressSink` no longer exists - `Address` now implements `Sink` directly for any handlers returning `()`.
 - `Message` no longer exists - `Return` is now specified on the `Handler` trait itself.
 - `Address` is no longer `Sync`, due to it implementing `AddressSink`. You should just be able to clone it and then send
   it, though.
+- `Context::notify_interval` and `Context::notify_after` are now subject to back-pressure, in case the address mailbox
+  is full. These aren't API breaking but a semantic changes.
+- `stopping` has been removed in favour of `stop_self` and `stop_all`. If logic to determine if the actor should stop
+  must be executed, it should be done rather at the point of calling `stop_{self,all}`.
+- Previously, `stop_all` would immediately disconnect the address. However, `stop_self` done on every actor would actually
+  not do this in one case - if there were a free-floating (not executing an actor event loop) Context. This change brings
+  `stop_all` in line with `stop_self`.
 
 ## 0.5.0
 

examples/message_stealing.rs

@@ -43,7 +43,7 @@ impl Handler<Print> for Printer {
 
         if self.times == 10 {
             println!("Actor {} stopping!", self.id);
-            ctx.stop();
+            ctx.stop_all();
         }
     }
 }
@@ -55,6 +55,11 @@ async fn main() {
         smol::spawn(ctx.attach(Printer::new(n))).detach();
     }
 
+    // This must be dropped, otherwise it will keep the actors from correctly shutting down. It
+    // doesn't affect this example, but it's best practice if not planning to use this behaviour
+    // intentionally.
+    drop(ctx);
+
     while addr.send(Print("hello".to_string())).await.is_ok() {}
     println!("Stopping to send");
 

src/address.rs

@@ -50,6 +50,7 @@ pub struct Address<A: 'static, Rc: RefCounter = Strong> {
 impl<A, Rc: RefCounter> Debug for Address<A, Rc> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.debug_struct(&format!("Address<{}>", std::any::type_name::<A>()))
+            .field("connected", &self.is_connected())
             .field("ref_counter", &self.ref_counter)
             .finish()
     }
@@ -87,7 +88,7 @@ impl<A> Address<A, Either> {
 
 /// Functions which apply to any kind of address, be they strong or weak.
 impl<A, Rc: RefCounter> Address<A, Rc> {
-    /// Returns whether the actor referred to by this address is running and accepting messages.
+    /// Returns whether the actors referred to by this address are running and accepting messages.
     ///
     /// ```rust
     /// # use xtra::prelude::*;
@@ -101,7 +102,7 @@ impl<A, Rc: RefCounter> Address<A, Rc> {
     ///     type Return = ();
     ///
     ///     async fn handle(&mut self, _: Shutdown, ctx: &mut Context<Self>) {
-    ///         ctx.stop();
+    ///         ctx.stop_all();
     ///     }
     /// }
     ///
@@ -115,7 +116,7 @@ impl<A, Rc: RefCounter> Address<A, Rc> {
     /// })
     /// ```
     pub fn is_connected(&self) -> bool {
-        !self.sink.is_disconnected()
+        !self.sink.is_disconnected() && self.ref_counter.is_connected()
     }
 
     /// Returns the number of messages in the actor's mailbox.
@@ -208,7 +209,9 @@ impl<A, Rc: RefCounter> Address<A, Rc> {
         }
     }
 
-    /// Waits until this address becomes disconnected.
+    /// Waits until this address becomes disconnected. Note that if this is called on a strong
+    /// address, it will only ever trigger if the actor calls [`Context::stop`], as the address
+    /// would prevent the actor being dropped due to too few strong addresses.
     pub fn join(&self) -> ActorJoinHandle {
         ActorJoinHandle(self.ref_counter.disconnect_notice())
     }