1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
#[macro_use]
extern crate failure;
#[macro_use]
extern crate serde_derive;
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 url_serde;
extern crate flexi_logger;
extern crate walkdir;
extern crate libeditor;
extern crate libanalysis;
extern crate libsyntax2;
extern crate im;
mod io;
mod caps;
mod req;
mod dispatch;
mod conv;
mod main_loop;
mod vfs;
mod path_map;
use threadpool::ThreadPool;
use crossbeam_channel::bounded;
use flexi_logger::{Logger, Duplicate};
use libanalysis::WorldState;
use ::{
io::{Io, RawMsg, RawResponse, RawRequest, RawNotification},
path_map::PathMap,
};
pub type Result<T> = ::std::result::Result<T, ::failure::Error>;
fn main() -> Result<()> {
Logger::with_env()
.duplicate_to_stderr(Duplicate::All)
.log_to_file()
.directory("log")
.start()?;
info!("lifecycle: server started");
match ::std::panic::catch_unwind(|| main_inner()) {
Ok(res) => {
info!("lifecycle: terminating process with {:?}", res);
res
}
Err(_) => {
error!("server panicked");
bail!("server panicked")
}
}
}
fn main_inner() -> Result<()> {
let mut io = Io::from_stdio();
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<()> {
match io.recv()? {
RawMsg::Notification(n) =>
bail!("expected initialize request, got {:?}", n),
RawMsg::Response(res) =>
bail!("expected initialize request, got {:?}", res),
RawMsg::Request(req) => {
let mut req = Some(req);
dispatch::handle_request::<req::Initialize, _>(&mut req, |_params, resp| {
let res = req::InitializeResult { capabilities: caps::server_capabilities() };
let resp = resp.into_response(Ok(res))?;
io.send(RawMsg::Response(resp));
Ok(())
})?;
if let Some(req) = req {
bail!("expected initialize request, got {:?}", req)
}
match io.recv()? {
RawMsg::Notification(n) => {
if n.method != "initialized" {
bail!("expected initialized notification");
}
}
_ => bail!("expected initialized notification"),
}
}
}
initialized(io)
}
enum Task {
Respond(RawResponse),
Request(RawRequest),
Notify(RawNotification),
Die(::failure::Error),
}
fn initialized(io: &mut Io) -> Result<()> {
{
let mut world = WorldState::new();
let mut pool = ThreadPool::new(4);
let (task_sender, task_receiver) = bounded::<Task>(16);
let (fs_events_receiver, watcher) = vfs::watch(vec![
::std::env::current_dir()?,
]);
info!("lifecycle: handshake finished, server ready to serve requests");
let res = main_loop::main_loop(
io,
&mut world,
&mut pool,
task_sender,
task_receiver.clone(),
fs_events_receiver,
);
info!("waiting for background jobs to finish...");
task_receiver.for_each(drop);
pool.join();
info!("...background jobs have finished");
info!("waiting for file watcher to finish...");
watcher.stop()?;
info!("...file watcher has finished");
res
}?;
match io.recv()? {
RawMsg::Notification(n) => {
if n.method == "exit" {
info!("lifecycle: shutdown complete");
return Ok(());
}
bail!("unexpected notification during shutdown: {:?}", n)
}
m => {
bail!("unexpected message during shutdown: {:?}", m)
}
}
}
|
