Debian Codegraph @

LspCpp/src/jsonrpc/TcpServer.cpp

raw
1 //
2 // server.cpp
3
4 #include "LibLsp/JsonRpc/TcpServer.h"
5 #include <signal.h>
6 #include <utility>
7 #include <LibLsp/lsp/asio.h>
8 #include "LibLsp/JsonRpc/MessageIssue.h"
9 #include "LibLsp/JsonRpc/stream.h"
10
11 namespace lsp
12 {
13 struct tcp_connect_session;
14
15 class tcp_stream_wrapper : public istream, public ostream
16 {
17 public:
18 tcp_stream_wrapper(tcp_connect_session& _w);
19
20 tcp_connect_session& session;
21 std::atomic<bool> quit {};
22 std::shared_ptr<MultiQueueWaiter> request_waiter;
23 ThreadedQueue<char> on_request;
24 std::string error_message;
25
26 bool fail() override
27 {
28 return bad();
29 }
30
31 bool eof() override
32 {
33 return bad();
34 }
35 bool good() override
36 {
37 return !bad();
38 }
39 tcp_stream_wrapper& read(char* str, std::streamsize count) override
40 {
41 auto some = on_request.TryDequeueSome(static_cast<size_t>(count));
42 memcpy(str, some.data(), some.size());
43 for (std::streamsize i = some.size(); i < count; ++i)
44 {
45 str[i] = static_cast<char>(get());
46 }
47
48 return *this;
49 }
50 int get() override
51 {
52 return on_request.Dequeue();
53 }
54
55 bool bad() override;
56
57 tcp_stream_wrapper& write(std::string const& c) override;
58
59 tcp_stream_wrapper& write(std::streamsize _s) override;
60
61 tcp_stream_wrapper& flush() override
62 {
63 return *this;
64 }
65 void reset_state()
66 {
67 return;
68 }
69
70 void clear() override
71 {
72 }
73
74 std::string what() override;
75 bool need_to_clear_the_state() override
76 {
77 return false;
78 }
79 };
80 struct tcp_connect_session : std::enable_shared_from_this<tcp_connect_session>
81 {
82 /// Buffer for incoming data.
83 std::array<unsigned char, 8192> buffer_;
84 asio::ip::tcp::socket socket_;
85 /// Strand to ensure the connection's handlers are not called concurrently.
86 asio::io_context::strand strand_;
87 std::shared_ptr<tcp_stream_wrapper> proxy_;
88 explicit tcp_connect_session(asio::io_context& io_context, asio::ip::tcp::socket&& _socket)
89 : socket_(std::move(_socket)), strand_(io_context), proxy_(new tcp_stream_wrapper(*this))
90 {
91 do_read();
92 }
93 void do_write(char const* data, size_t size)
94 {
95 socket_.async_write_some(
96 asio::buffer(data, size), asio::bind_executor(
97 strand_,
98 [this](asio_error_code ec, std::size_t)
99 {
100 if (!ec)
101 {
102 return;
103 }
104 proxy_->error_message = ec.message();
105 }
106 )
107 );
108 }
109 void do_read()
110 {
111 socket_.async_read_some(
112 asio::buffer(buffer_),
113 asio::bind_executor(
114 strand_,
115 [this](asio_error_code ec, size_t bytes_transferred)
116 {
117 if (!ec)
118 {
119 std::vector<char> elements(buffer_.data(), buffer_.data() + bytes_transferred);
120 proxy_->on_request.EnqueueAll(std::move(elements), false);
121 do_read();
122 return;
123 }
124 proxy_->error_message = ec.message();
125 }
126 )
127 );
128 }
129 };
130
131 tcp_stream_wrapper::tcp_stream_wrapper(tcp_connect_session& _w) : session(_w)
132 {
133 }
134
135 bool tcp_stream_wrapper::bad()
136 {
137 return !session.socket_.is_open();
138 }
139
140 tcp_stream_wrapper& tcp_stream_wrapper::write(std::string const& c)
141 {
142 size_t off = 0;
143 for (; off < c.size();)
144 {
145 if (off + 1024 < c.size())
146 {
147 session.do_write(c.data() + off, 1024);
148 off += 1024;
149 }
150 else
151 {
152 session.do_write(c.data() + off, c.size() - off);
153 break;
154 }
155 }
156 return *this;
157 }
158
159 tcp_stream_wrapper& tcp_stream_wrapper::write(std::streamsize _s)
160 {
161 auto s = std::to_string(_s);
162 session.do_write(s.data(), s.size());
163 return *this;
164 }
165
166 std::string tcp_stream_wrapper::what()
167 {
168 if (error_message.size())
169 {
170 return error_message;
171 }
172
173 if (!session.socket_.is_open())
174 {
175 return "Socket is not open.";
176 }
177 return {};
178 }
179
180 struct TcpServer::Data
181 {
182 Data(lsp::Log& log, uint32_t) : acceptor_(io_context_), _log(log)
183 {
184 }
185
186 ~Data()
187 {
188 }
189 /// The io_context used to perform asynchronous operations.
190 asio::io_context io_context_;
191
192 std::shared_ptr<asio::executor_work_guard<asio::io_context::executor_type>> work;
193
194 std::shared_ptr<tcp_connect_session> _connect_session;
195 /// Acceptor used to listen for incoming connections.
196 asio::ip::tcp::acceptor acceptor_;
197
198 lsp::Log& _log;
199 };
200
201 TcpServer::~TcpServer()
202 {
203 delete d_ptr;
204 }
205
206 TcpServer::TcpServer(
207 std::string const& address, std::string const& port, std::shared_ptr<MessageJsonHandler> json_handler,
208 std::shared_ptr<Endpoint> localEndPoint, lsp::Log& log, uint32_t _max_workers
209 )
210 : point(json_handler, localEndPoint, log, lsp::JSONStreamStyle::Standard, static_cast<uint8_t>(_max_workers)),
211 d_ptr(new Data(log, _max_workers))
212
213 {
214
215 d_ptr->work = std::make_shared<asio::executor_work_guard<asio::io_context::executor_type>>(
216 d_ptr->io_context_.get_executor()
217 );
218
219 // Open the acceptor with the option to reuse the address (i.e. SO_REUSEADDR).
220 asio::ip::tcp::resolver resolver(d_ptr->io_context_);
221 asio::ip::tcp::endpoint endpoint = *resolver.resolve(address, port).begin();
222 d_ptr->acceptor_.open(endpoint.protocol());
223 d_ptr->acceptor_.set_option(asio::ip::tcp::acceptor::reuse_address(true));
224 try
225 {
226 d_ptr->acceptor_.bind(endpoint);
227 }
228 catch (asio_system_error& e)
229 {
230 std::string temp = "Socket Server bind failed.";
231 d_ptr->_log.log(lsp::Log::Level::INFO, temp + e.what());
232 return;
233 }
234 d_ptr->acceptor_.listen();
235
236 do_accept();
237 std::string desc = "Socket TcpServer " + address + " " + port + " start.";
238 d_ptr->_log.log(lsp::Log::Level::INFO, desc);
239 }
240
241 void TcpServer::run()
242 {
243 // The io_context::run() call will block until all asynchronous operations
244 // have finished. While the TcpServer is running, there is always at least one
245 // asynchronous operation outstanding: the asynchronous accept call waiting
246 // for new incoming connections.
247 d_ptr->io_context_.run();
248 }
249
250 void TcpServer::stop()
251 {
252 try
253 {
254 if (d_ptr->work)
255 {
256 d_ptr->work.reset();
257 }
258
259 do_stop();
260 }
261 catch (...)
262 {
263 }
264 }
265
266 void TcpServer::do_accept()
267 {
268 d_ptr->acceptor_.async_accept(
269 [this](asio_error_code ec, asio::ip::tcp::socket socket)
270 {
271 // Check whether the TcpServer was stopped by a signal before this
272 // completion handler had a chance to run.
273 if (!d_ptr->acceptor_.is_open())
274 {
275 return;
276 }
277
278 if (!ec)
279 {
280 if (d_ptr->_connect_session)
281 {
282 if (d_ptr->_connect_session->socket_.is_open())
283 {
284 std::string desc = "Disconnect previous client "
285 + d_ptr->_connect_session->socket_.local_endpoint().address().to_string();
286 d_ptr->_log.log(lsp::Log::Level::INFO, desc);
287 d_ptr->_connect_session->socket_.close();
288 }
289
290 point.stop();
291 }
292 auto local_point = socket.local_endpoint();
293
294 std::string desc = ("New client " + local_point.address().to_string() + " connect.");
295 d_ptr->_log.log(lsp::Log::Level::INFO, desc);
296 d_ptr->_connect_session = std::make_shared<tcp_connect_session>(d_ptr->io_context_, std::move(socket));
297
298 point.startProcessingMessages(d_ptr->_connect_session->proxy_, d_ptr->_connect_session->proxy_);
299 do_accept();
300 }
301 }
302 );
303 }
304
305 void TcpServer::do_stop()
306 {
307 d_ptr->acceptor_.close();
308
309 point.stop();
310 }
311
312 } // namespace lsp