Make main function asynchronous

latex-lsp · Jun 11, 2019 · 0a5c7db · 0a5c7db
1 parent e0f359c
commit 0a5c7db
Show file tree

Hide file tree

Showing 4 changed files with 8 additions and 22 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/jsonrpc/Cargo.toml b/jsonrpc/Cargo.toml
@@ -9,6 +9,7 @@ edition = "2018"
 [dependencies]
 futures-boxed = { path = "../futures_boxed" }
 futures-preview = { version = "0.3.0-alpha.15", features = ["compat"] }
+runtime = "0.3.0-alpha.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_repr = "0.1"
diff --git a/jsonrpc/src/lib.rs b/jsonrpc/src/lib.rs
@@ -10,18 +10,15 @@ pub use self::{
     types::*,
 };
 
-use futures::executor::ThreadPool;
 use futures::lock::Mutex;
 use futures::prelude::*;
-use futures::task::*;
 use std::sync::Arc;
 
 pub struct MessageHandler<S, C, I, O> {
     pub server: Arc<S>,
     pub client: Arc<C>,
     pub input: I,
     pub output: Arc<Mutex<O>>,
-    pub pool: ThreadPool,
 }
 
 impl<S, C, I, O> MessageHandler<S, C, I, O>
@@ -43,25 +40,20 @@ where
                 Ok(Message::Request(request)) => {
                     let server = Arc::clone(&self.server);
                     let output = Arc::clone(&self.output);
-                    let handler = async move {
+                    runtime::spawn(async move {
                         let response = server.handle_request(request).await;
                         let json = serde_json::to_string(&response).unwrap();
                         let mut output = output.lock().await;
                         output.send(json).await.unwrap();
                         server.execute_actions().await;
-                    };
-
-                    self.pool.spawn(handler).unwrap();
+                    });
                 }
                 Ok(Message::Notification(notification)) => {
                     self.server.handle_notification(notification);
-
                     let server = Arc::clone(&self.server);
-                    let handler = async move {
+                    runtime::spawn(async move {
                         server.execute_actions().await;
-                    };
-
-                    self.pool.spawn(handler).unwrap();
+                    });
                 }
                 Ok(Message::Response(response)) => {
                     self.client.handle(response).await;

diff --git a/src/main.rs b/src/main.rs
@@ -2,9 +2,7 @@
 
 use clap::*;
 use futures::compat::*;
-use futures::executor::*;
 use futures::lock::Mutex;
-use futures::prelude::*;
 use jsonrpc::MessageHandler;
 use std::sync::Arc;
 use stderrlog::{ColorChoice, Timestamp};
@@ -15,7 +13,8 @@ use tokio::codec::FramedRead;
 use tokio_codec::FramedWrite;
 use tokio_stdin_stdout;
 
-fn main() {
+#[runtime::main]
+async fn main() {
     let matches = app_from_crate!()
         .author("")
         .arg(
@@ -41,12 +40,6 @@ fn main() {
         .init()
         .unwrap();
 
-    let mut pool = ThreadPool::new().expect("Failed to create the thread pool");
-    let task = run(pool.clone());
-    pool.run(task.unit_error()).unwrap();
-}
-
-async fn run(pool: ThreadPool) {
     let stdin = tokio_stdin_stdout::stdin(0);
     let stdout = tokio_stdin_stdout::stdout(0);
     let input = FramedRead::new(stdin, LspCodec).compat();
@@ -58,7 +51,6 @@ async fn run(pool: ThreadPool) {
         client,
         input,
         output,
-        pool,
     };
 
     handler.listen().await;