prepare rt release

Allow Actix to be started on an external CurrentThread runtime

actix-connect/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+### Changed
+
+* Update `derive_more` to 0.15
+
 ## [0.2.0] - 2019-05-12
 
 ### Changed

actix-connect/Cargo.toml

@@ -33,7 +33,7 @@ uri = ["http"]
 actix-service = "0.4.0"
 actix-codec = "0.1.2"
 actix-utils = "0.4.0"
-derive_more = "0.14.0"
+derive_more = "0.15"
 either = "1.5.2"
 futures = "0.1.25"
 http = { version = "0.1.17", optional = true }

actix-rt/CHANGES.md

@@ -1,11 +1,19 @@
 # Changes
 
+## [0.2.3] - 2019-06-22
+
+### Added
+
+* Allow to start System using exsiting CurrentThread Handle #22
+
+
 ## [0.2.2] - 2019-03-28
 
 ### Changed
 
 * Moved `blocking` module to `actix-threadpool` crate
 
+
 ## [0.2.1] - 2019-03-11
 
 ### Added
@@ -16,12 +24,14 @@
 
 * Arbiter::exec - execute fn on the arbiter's thread and wait result
 
+
 ## [0.2.0] - 2019-03-06
 
 * `run` method returns `io::Result<()>`
 
 * Removed `Handle`
 
+
 ## [0.1.0] - 2018-12-09
 
 * Initial release

actix-rt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "actix-rt"
-version = "0.2.2"
+version = "0.2.3"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix runtime"
 keywords = ["network", "framework", "async", "futures"]
@@ -18,7 +18,7 @@ name = "actix_rt"
 path = "src/lib.rs"
 
 [dependencies]
-actix-threadpool = "0.1.0"
+actix-threadpool = "0.1.1"
 futures = "0.1.25"
 tokio-current-thread = "0.1"
 tokio-executor = "0.1.5"

actix-rt/src/builder.rs

@@ -1,11 +1,12 @@
 use std::borrow::Cow;
 use std::io;
 
+use futures::future;
 use futures::future::{lazy, Future};
 use futures::sync::mpsc::unbounded;
 use futures::sync::oneshot::{channel, Receiver};
 
-use tokio_current_thread::CurrentThread;
+use tokio_current_thread::{CurrentThread, Handle};
 use tokio_reactor::Reactor;
 use tokio_timer::clock::Clock;
 use tokio_timer::timer::Timer;
@@ -69,6 +70,13 @@ impl Builder {
         self.create_runtime(|| {})
     }
 
+    /// Create new System that can run asynchronously.
+    ///
+    /// This method panics if it cannot start the system arbiter
+    pub(crate) fn build_async(self, executor: Handle) -> AsyncSystemRunner {
+        self.create_async_runtime(executor)
+    }
+
     /// This function will start tokio runtime and will finish once the
     /// `System::stop()` message get called.
     /// Function `f` get called within tokio runtime context.
@@ -79,6 +87,21 @@ impl Builder {
         self.create_runtime(f).run()
     }
 
+    fn create_async_runtime(self, executor: Handle) -> AsyncSystemRunner {
+        let (stop_tx, stop) = channel();
+        let (sys_sender, sys_receiver) = unbounded();
+
+        let system = System::construct(sys_sender, Arbiter::new_system(), self.stop_on_panic);
+
+        // system arbiter
+        let arb = SystemArbiter::new(stop_tx, sys_receiver);
+
+        // start the system arbiter
+        executor.spawn(arb).expect("could not start system arbiter");
+
+        AsyncSystemRunner { stop, system }
+    }
+
     fn create_runtime<F>(self, f: F) -> SystemRunner
     where
         F: FnOnce() + 'static,
@@ -127,6 +150,42 @@ impl Builder {
     }
 }
 
+#[derive(Debug)]
+pub(crate) struct AsyncSystemRunner {
+    stop: Receiver<i32>,
+    system: System,
+}
+
+impl AsyncSystemRunner {
+    /// This function will start event loop and returns a future that
+    /// resolves once the `System::stop()` function is called.
+    pub(crate) fn run_nonblocking(self) -> impl Future<Item = (), Error = io::Error> + Send {
+        let AsyncSystemRunner { stop, .. } = self;
+
+        // run loop
+        future::lazy(|| {
+            Arbiter::run_system();
+            stop.then(|res| match res {
+                Ok(code) => {
+                    if code != 0 {
+                        Err(io::Error::new(
+                            io::ErrorKind::Other,
+                            format!("Non-zero exit code: {}", code),
+                        ))
+                    } else {
+                        Ok(())
+                    }
+                }
+                Err(e) => Err(io::Error::new(io::ErrorKind::Other, e)),
+            })
+            .then(|result| {
+                Arbiter::stop_system();
+                result
+            })
+        })
+    }
+}
+
 /// Helper object that runs System's event loop
 #[must_use = "SystemRunner must be run"]
 #[derive(Debug)]

actix-rt/src/system.rs

@@ -3,6 +3,8 @@ use std::io;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 use futures::sync::mpsc::UnboundedSender;
+use futures::Future;
+use tokio_current_thread::Handle;
 
 use crate::arbiter::{Arbiter, SystemCommand};
 use crate::builder::{Builder, SystemRunner};
@@ -55,6 +57,20 @@ impl System {
         Self::builder().name(name).build()
     }
 
+    #[allow(clippy::new_ret_no_self)]
+    /// Create new system using provided CurrentThread Handle.
+    ///
+    /// This method panics if it can not spawn system arbiter
+    pub fn run_in_executor<T: Into<String>>(
+        name: T,
+        executor: Handle,
+    ) -> impl Future<Item = (), Error = io::Error> + Send {
+        Self::builder()
+            .name(name)
+            .build_async(executor)
+            .run_nonblocking()
+    }
+
     /// Get current running system.
     pub fn current() -> System {
         CURRENT.with(|cell| match *cell.borrow() {

actix-threadpool/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+### Changed
+
+* Update `derive_more` to 0.15
+
 ## [0.1.1] - 2019-06-05
 
 * Update parking_lot

actix-threadpool/Cargo.toml

@@ -18,7 +18,7 @@ name = "actix_threadpool"
 path = "src/lib.rs"
 
 [dependencies]
-derive_more = "0.14"
+derive_more = "0.15"
 futures = "0.1.25"
 parking_lot = "0.8"
 lazy_static = "1.2"