1 files changed, 112 insertions, 14 deletions

diff --git a/codeless/server/src/main.rs b/codeless/server/src/main.rs
index 11b6b7067..92f6a400c 100644
--- a/codeless/server/src/main.rs
+++ b/codeless/server/src/main.rs
@@ -6,7 +6,12 @@ extern crate serde;
 extern crate serde_json;
 extern crate languageserver_types;
 extern crate drop_bomb;
+#[macro_use]
 extern crate crossbeam_channel;
+extern crate threadpool;
+#[macro_use]
+extern crate log;
+extern crate flexi_logger;
 extern crate libeditor;
 extern crate libanalysis;
 
@@ -16,16 +21,50 @@ mod req;
 mod dispatch;
 
 use languageserver_types::InitializeResult;
+use threadpool::ThreadPool;
+use crossbeam_channel::{bounded, Sender, Receiver};
+use flexi_logger::Logger;
 use libanalysis::WorldState;
-use self::io::{Io, RawMsg};
+
+use ::{
+    io::{Io, RawMsg},
+};
 
 pub type Result<T> = ::std::result::Result<T, ::failure::Error>;
 
 fn main() -> Result<()> {
+    Logger::with_env_or_str("m=trace")
+        .log_to_file()
+        .directory("log")
+        .start()?;
+    info!("starting server");
+    match ::std::panic::catch_unwind(|| main_inner()) {
+        Ok(res) => {
+            info!("shutting down: {:?}", res);
+            res
+        }
+        Err(_) => {
+            error!("server panicked");
+            bail!("server panicked")
+        },
+    }
+}
+
+fn main_inner() -> Result<()> {
     let mut io = Io::from_stdio();
-    initialize(&mut io)?;
-    io.stop()?;
-    Ok(())
+    let res = initialize(&mut io);
+    info!("shutting down IO...");
+    let io_res = io.stop();
+    info!("... IO is down");
+    match (res, io_res) {
+        (Ok(()), Ok(())) => Ok(()),
+        (res, Ok(())) => res,
+        (Ok(()), io_res) => io_res,
+        (res, Err(io_err)) => {
+            error!("shutdown error: {:?}", io_err);
+            res
+        }
+    }
 }
 
 fn initialize(io: &mut Io) -> Result<()> {
@@ -59,20 +98,69 @@ fn initialize(io: &mut Io) -> Result<()> {
     }
 }
 
+type Thunk = Box<for<'a> FnBox<&'a mut Io, Result<()>>>;
+
 fn initialized(io: &mut Io) -> Result<()> {
-    eprintln!("initialized");
-    let world = WorldState::new();
+    let mut world = WorldState::new();
+    let mut pool = ThreadPool::new(4);
+    let (sender, receiver) = bounded::<Thunk>(16);
+    let res = main_loop(io, &mut world, &mut pool, sender, receiver.clone());
+    info!("waiting for background jobs to finish...");
+    receiver.for_each(drop);
+    info!("...background jobs have finished");
+    res
+}
+
+fn main_loop(
+    io: &mut Io,
+    world: &mut WorldState,
+    pool: &mut ThreadPool,
+    sender: Sender<Thunk>,
+    receiver: Receiver<Thunk>,
+) -> Result<()> {
+    info!("server initialized, serving requests");
     loop {
-        match io.recv()? {
+        enum Event {
+            Msg(RawMsg),
+            Thunk(Thunk),
+            ReceiverDead,
+        }
+
+        let event = select! {
+            recv(io.receiver(), msg) => match msg {
+                Some(msg) => Event::Msg(msg),
+                None => Event::ReceiverDead,
+            },
+            recv(receiver, thunk) => Event::Thunk(thunk.unwrap()),
+        };
+
+        let msg = match event {
+            Event::ReceiverDead => {
+                io.cleanup_receiver()?;
+                unreachable!();
+            }
+            Event::Thunk(thunk) => {
+                thunk.call_box(io)?;
+                continue;
+            }
+            Event::Msg(msg) => msg,
+        };
+
+        match msg {
             RawMsg::Request(req) => {
-                let world = world.snapshot();
                 if let Some((params, resp)) = dispatch::expect::<req::SyntaxTree>(io, req)? {
-                    resp.respond_with(io, || {
-                        let path = params.text_document.uri.to_file_path()
-                            .map_err(|()| format_err!("invalid path"))?;
-                        let file = world.file_syntax(&path)?;
-                        Ok(libeditor::syntax_tree(&file))
-                    })?
+                    let world = world.snapshot();
+                    let sender = sender.clone();
+                    pool.execute(move || {
+                        let res: Result<String> = (|| {
+                            let path = params.text_document.uri.to_file_path()
+                                .map_err(|()| format_err!("invalid path"))?;
+                            let file = world.file_syntax(&path)?;
+                            Ok(libeditor::syntax_tree(&file))
+                        })();
+
+                        sender.send(Box::new(|io: &mut Io| resp.response(io, res)))
+                    });
                 }
             }
             msg => {
@@ -82,3 +170,13 @@ fn initialized(io: &mut Io) -> Result<()> {
     }
 }
 
+
+trait FnBox<A, R>: Send {
+    fn call_box(self: Box<Self>, a: A) -> R;
+}
+
+impl<A, R, F: FnOnce(A) -> R + Send> FnBox<A, R> for F {
+    fn call_box(self: Box<F>, a: A) -> R {
+        (*self)(a)
+    }
+}