src/examples/cpp03/timeouts/server.cpp | src/examples/cpp11/timeouts/server.cpp |
⋮ | ⋮ |
1 | // | 1 | // |
2 | //·server.cpp | 2 | //·server.cpp |
3 | //·~~~~~~~~~~ | 3 | //·~~~~~~~~~~ |
4 | // | 4 | // |
5 | //·Copyright·(c)·2003-2022·Christopher·M.·Kohlhoff·(chris·at·kohlhoff·dot·com) | 5 | //·Copyright·(c)·2003-2022·Christopher·M.·Kohlhoff·(chris·at·kohlhoff·dot·com) |
6 | // | 6 | // |
7 | //·Distributed·under·the·Boost·Software·License,·Version·1.0.·(See·accompanying | 7 | //·Distributed·under·the·Boost·Software·License,·Version·1.0.·(See·accompanying |
8 | //·file·LICENSE_1_0.txt·or·copy·at·http://www.boost.org/LICENSE_1_0.txt) | 8 | //·file·LICENSE_1_0.txt·or·copy·at·http://www.boost.org/LICENSE_1_0.txt) |
9 | // | 9 | // |
10 | | 10 | |
11 | #include·<algorithm> | 11 | #include·<algorithm> |
12 | #include·<cstdlib> | 12 | #include·<cstdlib> |
13 | #include·<deque> | 13 | #include·<deque> |
14 | #include·<iostream> | 14 | #include·<iostream> |
| 15 | #include·<memory> |
15 | #include·<set> | 16 | #include·<set> |
16 | #include·<string> | 17 | #include·<string> |
17 | #include·<boost/bind/bind.hpp> | |
18 | #include·<boost/shared_ptr.hpp> | |
19 | #include·<boost/enable_shared_from_this.hpp> | |
20 | #include·"asio/buffer.hpp" | 18 | #include·"asio/buffer.hpp" |
21 | #include·"asio/io_context.hpp" | 19 | #include·"asio/io_context.hpp" |
22 | #include·"asio/ip/tcp.hpp" | 20 | #include·"asio/ip/tcp.hpp" |
23 | #include·"asio/ip/udp.hpp" | 21 | #include·"asio/ip/udp.hpp" |
24 | #include·"asio/read_until.hpp" | 22 | #include·"asio/read_until.hpp" |
25 | #include·"asio/steady_timer.hpp" | 23 | #include·"asio/steady_timer.hpp" |
26 | #include·"asio/write.hpp" | 24 | #include·"asio/write.hpp" |
27 | | 25 | |
28 | using·asio::steady_timer; | 26 | using·asio::steady_timer; |
29 | using·asio::ip::tcp; | 27 | using·asio::ip::tcp; |
30 | using·asio::ip::udp; | 28 | using·asio::ip::udp; |
31 | | 29 | |
32 | //---------------------------------------------------------------------- | 30 | //---------------------------------------------------------------------- |
33 | | 31 | |
34 | class·subscriber | 32 | class·subscriber |
35 | { | 33 | { |
36 | public: | 34 | public: |
37 | ··virtual·~subscriber()·{} | 35 | ··virtual·~subscriber()·=·default; |
38 | ··virtual·void·deliver(const·std::string&·msg)·=·0; | 36 | ··virtual·void·deliver(const·std::string&·msg)·=·0; |
39 | }; | 37 | }; |
40 | | 38 | |
41 | typedef·boost::shared_ptr<subscriber>·subscriber_ptr; | 39 | typedef·std::shared_ptr<subscriber>·subscriber_ptr; |
42 | | 40 | |
43 | //---------------------------------------------------------------------- | 41 | //---------------------------------------------------------------------- |
44 | | 42 | |
45 | class·channel | 43 | class·channel |
46 | { | 44 | { |
47 | public: | 45 | public: |
48 | ··void·join(subscriber_ptr·subscriber) | 46 | ··void·join(subscriber_ptr·subscriber) |
49 | ··{ | 47 | ··{ |
50 | ····subscribers_.insert(subscriber); | 48 | ····subscribers_.insert(subscriber); |
51 | ··} | 49 | ··} |
52 | | 50 | |
53 | ··void·leave(subscriber_ptr·subscriber) | 51 | ··void·leave(subscriber_ptr·subscriber) |
54 | ··{ | 52 | ··{ |
55 | ····subscribers_.erase(subscriber); | 53 | ····subscribers_.erase(subscriber); |
56 | ··} | 54 | ··} |
57 | | 55 | |
58 | ··void·deliver(const·std::string&·msg) | 56 | ··void·deliver(const·std::string&·msg) |
59 | ··{ | 57 | ··{ |
60 | ····std::for_each(subscribers_.begin(),·subscribers_.end(), | 58 | ····for·(const·auto&·s·:·subscribers_) |
61 | ········boost::bind(&subscriber::deliver, | 59 | ····{ |
62 | ··········boost::placeholders::_1,·boost::ref(msg))); | 60 | ······s->deliver(msg); |
| 61 | ····} |
63 | ··} | 62 | ··} |
64 | | 63 | |
65 | private: | 64 | private: |
66 | ··std::set<subscriber_ptr>·subscribers_; | 65 | ··std::set<subscriber_ptr>·subscribers_; |
67 | }; | 66 | }; |
68 | | 67 | |
69 | //---------------------------------------------------------------------- | 68 | //---------------------------------------------------------------------- |
70 | | 69 | |
71 | // | 70 | // |
72 | //·This·class·manages·socket·timeouts·by·applying·the·concept·of·a·deadline. | 71 | //·This·class·manages·socket·timeouts·by·applying·the·concept·of·a·deadline. |
73 | //·Some·asynchronous·operations·are·given·deadlines·by·which·they·must·complete. | 72 | //·Some·asynchronous·operations·are·given·deadlines·by·which·they·must·complete. |
74 | //·Deadlines·are·enforced·by·two·"actors"·that·persist·for·the·lifetime·of·the | 73 | //·Deadlines·are·enforced·by·two·"actors"·that·persist·for·the·lifetime·of·the |
75 | //·session·object,·one·for·input·and·one·for·output: | 74 | //·session·object,·one·for·input·and·one·for·output: |
76 | // | 75 | // |
77 | //··+----------------+·····················+----------------+ | 76 | //··+----------------+······················+----------------+ |
78 | //··|················|·····················|················| | 77 | //··|················|······················|················| |
79 | //··|·check_deadline·|<---+················|·check_deadline·|<---+ | 78 | //··|·check_deadline·|<-------+·············|·check_deadline·|<-------+ |
80 | //··|················|····|·async_wait()···|················|····|·async_wait() | 79 | //··|················|········|·············|················|········| |
81 | //··+----------------+····|··on·input······+----------------+····|··on·output | 80 | //··+----------------+········|·············+----------------+········| |
82 | //··············|·········|··deadline··················|·········|··deadline | 81 | //···············|············|··························|············| |
83 | //··············+---------+····························+---------+ | 82 | //··async_wait()·|····+----------------+····async_wait()·|····+----------------+ |
| 83 | //···on·input····|····|·····lambda·····|·····on·output···|····|·····lambda·····| |
| 84 | //···deadline····+--->|·······in·······|·····deadline····+--->|·······in·······| |
| 85 | //····················|·check_deadline·|······················|·check_deadline·| |
| 86 | //····················+----------------+······················+----------------+ |
84 | // | 87 | // |
85 | //·If·either·deadline·actor·determines·that·the·corresponding·deadline·has | 88 | //·If·either·deadline·actor·determines·that·the·corresponding·deadline·has |
86 | //·expired,·the·socket·is·closed·and·any·outstanding·operations·are·cancelled. | 89 | //·expired,·the·socket·is·closed·and·any·outstanding·operations·are·cancelled. |
87 | // | 90 | // |
88 | //·The·input·actor·reads·messages·from·the·socket,·where·messages·are·delimited | 91 | //·The·input·actor·reads·messages·from·the·socket,·where·messages·are·delimited |
89 | //·by·the·newline·character: | 92 | //·by·the·newline·character: |
90 | // | 93 | // |
91 | //··+------------+ | 94 | //··+-------------+ |
92 | //··|············| | 95 | //··|·············| |
93 | //··|·start_read·|<---+ | 96 | //··|··read_line··|<----+ |
94 | //··|············|····| | 97 | //··|·············|·····| |
95 | //··+------------+····| | 98 | //··+-------------+·····| |
96 | //··········|·········| | 99 | //··········|···········| |
97 | //··async_-·|····+-------------+ | 100 | //··async_-·|····+-------------+ |
98 | //···read_-·|····|·············| | 101 | //···read_-·|····|···lambda····| |
99 | //··until()·+--->|·handle_read·| | 102 | //··until()·+--->|·····in······| |
100 | //···············|·············| | 103 | //···············|··read_line··| |
101 | //···············+-------------+ | 104 | //···············+-------------+ |
102 | // | 105 | // |
103 | //·The·deadline·for·receiving·a·complete·message·is·30·seconds.·If·a·non-empty | 106 | //·The·deadline·for·receiving·a·complete·message·is·30·seconds.·If·a·non-empty |
104 | //·message·is·received,·it·is·delivered·to·all·subscribers.·If·a·heartbeat·(a | 107 | //·message·is·received,·it·is·delivered·to·all·subscribers.·If·a·heartbeat·(a |
105 | //·message·that·consists·of·a·single·newline·character)·is·received,·a·heartbeat | 108 | //·message·that·consists·of·a·single·newline·character)·is·received,·a·heartbeat |
106 | //·is·enqueued·for·the·client,·provided·there·are·no·other·messages·waiting·to | 109 | //·is·enqueued·for·the·client,·provided·there·are·no·other·messages·waiting·to |
107 | //·be·sent. | 110 | //·be·sent. |
108 | // | 111 | // |
109 | //·The·output·actor·is·responsible·for·sending·messages·to·the·client: | 112 | //·The·output·actor·is·responsible·for·sending·messages·to·the·client: |
110 | // | 113 | // |
111 | //··+--------------+ | 114 | //··+----------------+ |
112 | //··|··············|<---------------------+ | 115 | //··|················|<---------------------+ |
113 | //··|·await_output·|······················| | 116 | //··|··await_output··|······················| |
114 | //··|··············|<---+·················| | 117 | //··|················|<-------+·············| |
115 | //··+--------------+····|·················| | 118 | //··+----------------+········|·············| |
116 | //······|······|········|·async_wait()····| | 119 | //····|············|··········|·············| |
117 | //······|······+--------+·················| | 120 | //····|····async_-·|··+----------------+····| |
118 | //······V·································| | 121 | //····|·····wait()·|··|·····lambda·····|····| |
119 | //··+-------------+···············+--------------+ | 122 | //····|············+->|·······in·······|····| |
120 | //··|·············|·async_write()·|··············| | 123 | //····|···············|··await_output··|····| |
121 | //··|·start_write·|-------------->|·handle_write·| | 124 | //····|···············+----------------+····| |
122 | //··|·············|···············|··············| | 125 | //····V·····································| |
123 | //··+-------------+···············+--------------+ | 126 | //··+--------------+···············+--------------+ |
| 127 | //··|··············|·async_write()·|····lambda····| |
| 128 | //··|··write_line··|-------------->|······in······| |
| 129 | //··|··············|···············|··write_line··| |
| 130 | //··+--------------+···············+--------------+ |
124 | // | 131 | // |
125 | //·The·output·actor·first·waits·for·an·output·message·to·be·enqueued.·It·does | 132 | //·The·output·actor·first·waits·for·an·output·message·to·be·enqueued.·It·does |
126 | //·this·by·using·a·steady_timer·as·an·asynchronous·condition·variable.·The | 133 | //·this·by·using·a·steady_timer·as·an·asynchronous·condition·variable.·The |
127 | //·steady_timer·will·be·signalled·whenever·the·output·queue·is·non-empty. | 134 | //·steady_timer·will·be·signalled·whenever·the·output·queue·is·non-empty. |
128 | // | 135 | // |
129 | //·Once·a·message·is·available,·it·is·sent·to·the·client.·The·deadline·for | 136 | //·Once·a·message·is·available,·it·is·sent·to·the·client.·The·deadline·for |
130 | //·sending·a·complete·message·is·30·seconds.·After·the·message·is·successfully | 137 | //·sending·a·complete·message·is·30·seconds.·After·the·message·is·successfully |
131 | //·sent,·the·output·actor·again·waits·for·the·output·queue·to·become·non-empty. | 138 | //·sent,·the·output·actor·again·waits·for·the·output·queue·to·become·non-empty. |
132 | // | 139 | // |
133 | class·tcp_session | 140 | class·tcp_session |
134 | ··:·public·subscriber, | 141 | ··:·public·subscriber, |
135 | ····public·boost::enable_shared_from_this<tcp_session> | 142 | ····public·std::enable_shared_from_this<tcp_session> |
136 | { | 143 | { |
137 | public: | 144 | public: |
138 | ··tcp_session(asio::io_context&·io_context,·channel&·ch) | 145 | ··tcp_session(tcp::socket·socket,·channel&·ch) |
139 | ····:·channel_(ch), | 146 | ····:·channel_(ch), |
140 | ······socket_(io_context), | 147 | ······socket_(std::move(socket)) |
141 | ······input_deadline_(io_context), | |
142 | ······non_empty_output_queue_(io_context), | |
143 | ······output_deadline_(io_context) | |
144 | ··{ | 148 | ··{ |
145 | ····input_deadline_.expires_at(steady_timer::time_point::max()); | 149 | ····input_deadline_.expires_at(steady_timer::time_point::max()); |
146 | ····output_deadline_.expires_at(steady_timer::time_point::max()); | 150 | ····output_deadline_.expires_at(steady_timer::time_point::max()); |
147 | | 151 | |
148 | ····//·The·non_empty_output_queue_·steady_timer·is·set·to·the·maximum·time | 152 | ····//·The·non_empty_output_queue_·steady_timer·is·set·to·the·maximum·time |
149 | ····//·point·whenever·the·output·queue·is·empty.·This·ensures·that·the·output | 153 | ····//·point·whenever·the·output·queue·is·empty.·This·ensures·that·the·output |
150 | ····//·actor·stays·asleep·until·a·message·is·put·into·the·queue. | 154 | ····//·actor·stays·asleep·until·a·message·is·put·into·the·queue. |
151 | ····non_empty_output_queue_.expires_at(steady_timer::time_point::max()); | 155 | ····non_empty_output_queue_.expires_at(steady_timer::time_point::max()); |
152 | ··} | 156 | ··} |
153 | | 157 | |
154 | ··tcp::socket&·socket() | |
155 | ··{ | |
156 | ····return·socket_; | |
157 | ··} | |
158 | | |
159 | ··//·Called·by·the·server·object·to·initiate·the·four·actors. | 158 | ··//·Called·by·the·server·object·to·initiate·the·four·actors. |
160 | ··void·start() | 159 | ··void·start() |
161 | ··{ | 160 | ··{ |
162 | ····channel_.join(shared_from_this()); | 161 | ····channel_.join(shared_from_this()); |
163 | | 162 | |
164 | ····start_read(); | 163 | ····read_line(); |
165 | | 164 | ····check_deadline(input_deadline_); |
166 | ····input_deadline_.async_wait( | |
167 | ········boost::bind(&tcp_session::check_deadline, | |
168 | ········shared_from_this(),·&input_deadline_)); | |
169 | | 165 | |
170 | ····await_output(); | 166 | ····await_output(); |
171 | | 167 | ····check_deadline(output_deadline_); |
172 | ····output_deadline_.async_wait( | |
173 | ········boost::bind(&tcp_session::check_deadline, | |
174 | ········shared_from_this(),·&output_deadline_)); | |
175 | ··} | 168 | ··} |
176 | | 169 | |
177 | private: | 170 | private: |
178 | ··void·stop() | 171 | ··void·stop() |
179 | ··{ | 172 | ··{ |
180 | ····channel_.leave(shared_from_this()); | 173 | ····channel_.leave(shared_from_this()); |
181 | | 174 | |
182 | ····asio::error_code·ignored_ec; | 175 | ····std::error_code·ignored_error; |
183 | ····socket_.close(ignored_ec); | 176 | ····socket_.close(ignored_error); |
184 | ····input_deadline_.cancel(); | 177 | ····input_deadline_.cancel(); |
185 | ····non_empty_output_queue_.cancel(); | 178 | ····non_empty_output_queue_.cancel(); |
186 | ····output_deadline_.cancel(); | 179 | ····output_deadline_.cancel(); |
187 | ··} | 180 | ··} |
188 | | 181 | |
189 | ··bool·stopped()·const | 182 | ··bool·stopped()·const |
190 | ··{ | 183 | ··{ |
191 | ····return·!socket_.is_open(); | 184 | ····return·!socket_.is_open(); |
192 | ··} | 185 | ··} |
193 | | 186 | |
194 | ··void·deliver(const·std::string&·msg) | 187 | ··void·deliver(const·std::string&·msg)·override |
195 | ··{ | 188 | ··{ |
196 | ····output_queue_.push_back(msg·+·"\n"); | 189 | ····output_queue_.push_back(msg·+·"\n"); |
197 | | 190 | |
198 | ····//·Signal·that·the·output·queue·contains·messages.·Modifying·the·expiry | 191 | ····//·Signal·that·the·output·queue·contains·messages.·Modifying·the·expiry |
199 | ····//·will·wake·the·output·actor,·if·it·is·waiting·on·the·timer. | 192 | ····//·will·wake·the·output·actor,·if·it·is·waiting·on·the·timer. |
200 | ····non_empty_output_queue_.expires_at(steady_timer::time_point::min()); | 193 | ····non_empty_output_queue_.expires_at(steady_timer::time_point::min()); |
201 | ··} | 194 | ··} |
202 | | 195 | |
203 | ··void·start_read() | 196 | ··void·read_line() |
204 | ··{ | 197 | ··{ |
205 | ····//·Set·a·deadline·for·the·read·operation. | 198 | ····//·Set·a·deadline·for·the·read·operation. |
206 | ····input_deadline_.expires_after(asio::chrono::seconds(30)); | 199 | ····input_deadline_.expires_after(std::chrono::seconds(30)); |
207 | | 200 | |
208 | ····//·Start·an·asynchronous·operation·to·read·a·newline-delimited·message. | 201 | ····//·Start·an·asynchronous·operation·to·read·a·newline-delimited·message. |
| 202 | ····auto·self(shared_from_this()); |
209 | ····asio::async_read_until(socket_, | 203 | ····asio::async_read_until(socket_, |
210 | ········asio::dynamic_buffer(input_buffer_),·'\n', | 204 | ········asio::dynamic_buffer(input_buffer_),·'\n', |
211 | ········boost::bind(&tcp_session::handle_read,·shared_from_this(), | 205 | ········[this,·self](const·std::error_code&·error,·std::size_t·n) |
212 | ··········boost::placeholders::_1,·boost::placeholders::_2)); | |
213 | ··} | |
214 | | |
215 | ··void·handle_read(const·asio::error_code&·ec,·std::size_t·n) | |
216 | ··{ | |
217 | ····if·(stopped()) | |
218 | ······return; | |
219 | | |
220 | ····if·(!ec) | |
221 | ····{ | |
222 | ······//·Extract·the·newline-delimited·message·from·the·buffer. | |
223 | ······std::string·msg(input_buffer_.substr(0,·n·-·1)); | |
224 | ······input_buffer_.erase(0,·n); | |
225 | | |
226 | ······if·(!msg.empty()) | |
227 | ······{ | |
228 | ········channel_.deliver(msg); | |
229 | ······} | |
230 | ······else | |
231 | ······{ | |
232 | ········//·We·received·a·heartbeat·message·from·the·client.·If·there's·nothing | |
233 | ········//·else·being·sent·or·ready·to·be·sent,·send·a·heartbeat·right·back. | |
234 | ········if·(output_queue_.empty()) | |
235 | ········{ | 206 | ········{ |
236 | ··········output_queue_.push_back("\n"); | 207 | ··········//·Check·if·the·session·was·stopped·while·the·operation·was·pending. |
237 | | 208 | ··········if·(stopped()) |
238 | ··········//·Signal·that·the·output·queue·contains·messages.·Modifying·the | 209 | ············return; |
239 | ··········//·expiry·will·wake·the·output·actor,·if·it·is·waiting·on·the·timer. | 210 | |
240 | ··········non_empty_output_queue_.expires_at(steady_timer::time_point::min()); | 211 | ··········if·(!error) |
241 | ········} | 212 | ··········{ |
242 | ······} | 213 | ············//·Extract·the·newline-delimited·message·from·the·buffer. |
243 | | 214 | ············std::string·msg(input_buffer_.substr(0,·n·-·1)); |
244 | ······start_read(); | 215 | ············input_buffer_.erase(0,·n); |
245 | ····} | 216 | |
246 | ····else | 217 | ············if·(!msg.empty()) |
247 | ····{ | 218 | ············{ |
248 | ······stop(); | 219 | ··············channel_.deliver(msg); |
249 | ····} | 220 | ············} |
| 221 | ············else |
| 222 | ············{ |
| 223 | |
| 224 | ··············//·We·received·a·heartbeat·message·from·the·client.·If·there's |
| 225 | ··············//·nothing·else·being·sent·or·ready·to·be·sent,·send·a·heartbeat |
| 226 | ··············//·right·back. |
| 227 | ··············if·(output_queue_.empty()) |
| 228 | ··············{ |
| 229 | ················output_queue_.push_back("\n"); |
| 230 | |
| 231 | ················//·Signal·that·the·output·queue·contains·messages.·Modifying |
| 232 | ················//·the·expiry·will·wake·the·output·actor,·if·it·is·waiting·on |
| 233 | ················//·the·timer. |
| 234 | ················non_empty_output_queue_.expires_at( |
| 235 | ····················steady_timer::time_point::min()); |
| 236 | ··············} |
| 237 | ············} |
| 238 | |
| 239 | ············read_line(); |
| 240 | ··········} |
| 241 | ··········else |
| 242 | ··········{ |
| 243 | ············stop(); |
| 244 | ··········} |
| 245 | ········}); |
250 | ··} | 246 | ··} |
251 | | 247 | |
252 | ··void·await_output() | 248 | ··void·await_output() |
253 | ··{ | 249 | ··{ |
254 | ····if·(stopped()) | 250 | ····auto·self(shared_from_this()); |
255 | ······return; | 251 | ····non_empty_output_queue_.async_wait( |
256 | | 252 | ········[this,·self](const·std::error_code&·/*error*/) |
257 | ····if·(output_queue_.empty()) | 253 | ········{ |
258 | ····{ | 254 | ··········//·Check·if·the·session·was·stopped·while·the·operation·was·pending. |
259 | ······//·There·are·no·messages·that·are·ready·to·be·sent.·The·actor·goes·to | 255 | ··········if·(stopped()) |
260 | ······//·sleep·by·waiting·on·the·non_empty_output_queue_·timer.·When·a·new | 256 | ············return; |
261 | ······//·message·is·added,·the·timer·will·be·modified·and·the·actor·will·wake. | 257 | |
262 | ······non_empty_output_queue_.expires_at(steady_timer::time_point::max()); | 258 | ··········if·(output_queue_.empty()) |
263 | ······non_empty_output_queue_.async_wait( | 259 | ··········{ |
264 | ··········boost::bind(&tcp_session::await_output,·shared_from_this())); | 260 | ············//·There·are·no·messages·that·are·ready·to·be·sent.·The·actor·goes |
265 | ····} | 261 | ············//·to·sleep·by·waiting·on·the·non_empty_output_queue_·timer.·When·a |
266 | ····else | 262 | ············//·new·message·is·added,·the·timer·will·be·modified·and·the·actor |
267 | ····{ | 263 | ············//·will·wake. |
268 | ······start_write(); | 264 | ············non_empty_output_queue_.expires_at(steady_timer::time_point::max()); |
269 | ····} | 265 | ············await_output(); |
| 266 | ··········} |
| 267 | ··········else |
| 268 | ··········{ |
| 269 | ············write_line(); |
| 270 | ··········} |
| 271 | ········}); |
270 | ··} | 272 | ··} |
271 | | 273 | |
272 | ··void·start_write() | 274 | ··void·write_line() |
273 | ··{ | 275 | ··{ |
274 | ····//·Set·a·deadline·for·the·write·operation. | 276 | ····//·Set·a·deadline·for·the·write·operation. |
275 | ····output_deadline_.expires_after(asio::chrono::seconds(30)); | 277 | ····output_deadline_.expires_after(std::chrono::seconds(30)); |
276 | | 278 | |
277 | ····//·Start·an·asynchronous·operation·to·send·a·message. | 279 | ····//·Start·an·asynchronous·operation·to·send·a·message. |
| 280 | ····auto·self(shared_from_this()); |
278 | ····asio::async_write(socket_, | 281 | ····asio::async_write(socket_, |
279 | ········asio::buffer(output_queue_.front()), | 282 | ········asio::buffer(output_queue_.front()), |
280 | ········boost::bind(&tcp_session::handle_write, | 283 | ········[this,·self](const·std::error_code&·error,·std::size_t·/*n*/) |
281 | ··········shared_from_this(),·boost::placeholders::_1)); | 284 | ········{ |
282 | ··} | 285 | ··········//·Check·if·the·session·was·stopped·while·the·operation·was·pending. |
283 | | 286 | ··········if·(stopped()) |
284 | ··void·handle_write(const·asio::error_code&·ec) | 287 | ············return; |
285 | ··{ | 288 | |
286 | ····if·(stopped()) | 289 | ··········if·(!error) |
287 | ······return; | 290 | ··········{ |
288 | | 291 | ············output_queue_.pop_front(); |
289 | ····if·(!ec) | 292 | |
290 | ····{ | 293 | ············await_output(); |
291 | ······output_queue_.pop_front(); | 294 | ··········} |
292 | | 295 | ··········else |
293 | ······await_output(); | 296 | ··········{ |
294 | ····} | 297 | ············stop(); |
295 | ····else | 298 | ··········} |
296 | ····{ | 299 | ········}); |
297 | ······stop(); | 300 | ··} |
298 | ····} | 301 | |
299 | ··} | 302 | ··void·check_deadline(steady_timer&·deadline) |
300 | | 303 | ··{ |
301 | ··void·check_deadline(steady_timer*·deadline) | 304 | ····auto·self(shared_from_this()); |
302 | ··{ | 305 | ····deadline.async_wait( |
303 | ····if·(stopped()) | 306 | ········[this,·self,·&deadline](const·std::error_code&·/*error*/) |
304 | ······return; | 307 | ········{ |
305 | | 308 | ··········//·Check·if·the·session·was·stopped·while·the·operation·was·pending. |
306 | ····//·Check·whether·the·deadline·has·passed.·We·compare·the·deadline·against | 309 | ··········if·(stopped()) |
307 | ····//·the·current·time·since·a·new·asynchronous·operation·may·have·moved·the | 310 | ············return; |
308 | ····//·deadline·before·this·actor·had·a·chance·to·run. | 311 | |
309 | ····if·(deadline->expiry()·<=·steady_timer::clock_type::now()) | 312 | ··········//·Check·whether·the·deadline·has·passed.·We·compare·the·deadline |
310 | ····{ | 313 | ··········//·against·the·current·time·since·a·new·asynchronous·operation·may |
311 | ······//·The·deadline·has·passed.·Stop·the·session.·The·other·actors·will | 314 | ··········//·have·moved·the·deadline·before·this·actor·had·a·chance·to·run. |
312 | ······//·terminate·as·soon·as·possible. | 315 | ··········if·(deadline.expiry()·<=·steady_timer::clock_type::now()) |
313 | ······stop(); | 316 | ··········{ |
314 | ····} | 317 | ············//·The·deadline·has·passed.·Stop·the·session.·The·other·actors·will |
315 | ····else | 318 | ············//·terminate·as·soon·as·possible. |
316 | ····{ | 319 | ············stop(); |
317 | ······//·Put·the·actor·back·to·sleep. | 320 | ··········} |
318 | ······deadline->async_wait( | 321 | ··········else |
319 | ··········boost::bind(&tcp_session::check_deadline, | 322 | ··········{ |
320 | ··········shared_from_this(),·deadline)); | 323 | ············//·Put·the·actor·back·to·sleep. |
321 | ····} | 324 | ············check_deadline(deadline); |
| 325 | ··········} |
| 326 | ········}); |
322 | ··} | 327 | ··} |
323 | | 328 | |
324 | ··channel&·channel_; | 329 | ··channel&·channel_; |
325 | ··tcp::socket·socket_; | 330 | ··tcp::socket·socket_; |
326 | ··std::string·input_buffer_; | 331 | ··std::string·input_buffer_; |
327 | ··steady_timer·input_deadline_; | 332 | ··steady_timer·input_deadline_{socket_.get_executor()}; |
328 | ··std::deque<std::string>·output_queue_; | 333 | ··std::deque<std::string>·output_queue_; |
329 | ··steady_timer·non_empty_output_queue_; | 334 | ··steady_timer·non_empty_output_queue_{socket_.get_executor()}; |
330 | ··steady_timer·output_deadline_; | 335 | ··steady_timer·output_deadline_{socket_.get_executor()}; |
331 | }; | 336 | }; |
332 | | 337 | |
333 | typedef·boost::shared_ptr<tcp_session>·tcp_session_ptr; | 338 | typedef·std::shared_ptr<tcp_session>·tcp_session_ptr; |
334 | | 339 | |
335 | //---------------------------------------------------------------------- | 340 | //---------------------------------------------------------------------- |
336 | | 341 | |
337 | class·udp_broadcaster | 342 | class·udp_broadcaster |
338 | ··:·public·subscriber | 343 | ··:·public·subscriber |
339 | { | 344 | { |
340 | public: | 345 | public: |
341 | ··udp_broadcaster(asio::io_context&·io_context, | 346 | ··udp_broadcaster(asio::io_context&·io_context, |
342 | ······const·udp::endpoint&·broadcast_endpoint) | 347 | ······const·udp::endpoint&·broadcast_endpoint) |
343 | ····:·socket_(io_context) | 348 | ····:·socket_(io_context) |
344 | ··{ | 349 | ··{ |
345 | ····socket_.connect(broadcast_endpoint); | 350 | ····socket_.connect(broadcast_endpoint); |
346 | ····socket_.set_option(udp::socket::broadcast(true)); | 351 | ····socket_.set_option(udp::socket::broadcast(true)); |
347 | ··} | 352 | ··} |
348 | | 353 | |
349 | private: | 354 | private: |
350 | ··void·deliver(const·std::string&·msg) | 355 | ··void·deliver(const·std::string&·msg) |
351 | ··{ | 356 | ··{ |
352 | ····asio::error_code·ignored_ec; | 357 | ····std::error_code·ignored_error; |
353 | ····socket_.send(asio::buffer(msg),·0,·ignored_ec); | 358 | ····socket_.send(asio::buffer(msg),·0,·ignored_error); |
354 | ··} | 359 | ··} |
355 | | 360 | |
356 | ··udp::socket·socket_; | 361 | ··udp::socket·socket_; |
357 | }; | 362 | }; |
358 | | 363 | |
359 | //---------------------------------------------------------------------- | 364 | //---------------------------------------------------------------------- |
360 | | 365 | |
361 | class·server | 366 | class·server |
362 | { | 367 | { |
363 | public: | 368 | public: |
364 | ··server(asio::io_context&·io_context, | 369 | ··server(asio::io_context&·io_context, |
365 | ······const·tcp::endpoint&·listen_endpoint, | 370 | ······const·tcp::endpoint&·listen_endpoint, |
366 | ······const·udp::endpoint&·broadcast_endpoint) | 371 | ······const·udp::endpoint&·broadcast_endpoint) |
367 | ····:·io_context_(io_context), | 372 | ····:·io_context_(io_context), |
368 | ······acceptor_(io_context,·listen_endpoint) | 373 | ······acceptor_(io_context,·listen_endpoint) |
369 | ··{ | 374 | ··{ |
370 | ····subscriber_ptr·bc(new·udp_broadcaster(io_context_,·broadcast_endpoint)); | 375 | ····channel_.join( |
371 | ····channel_.join(bc); | 376 | ········std::make_shared<udp_broadcaster>( |
| 377 | ··········io_context_,·broadcast_endpoint)); |
372 | | 378 | |
373 | ····start_accept(); | 379 | ····accept(); |
374 | ··} | 380 | ··} |
375 | | 381 | |
376 | ··void·start_accept() | 382 | private: |
377 | ··{ | 383 | ··void·accept() |
378 | ····tcp_session_ptr·new_session(new·tcp_session(io_context_,·channel_)); | |
379 | | |
380 | ····acceptor_.async_accept(new_session->socket(), | |
381 | ········boost::bind(&server::handle_accept, | |
382 | ··········this,·new_session,·boost::placeholders::_1)); | |
383 | ··} | |
384 | | |
385 | ··void·handle_accept(tcp_session_ptr·session, | |
386 | ······const·asio::error_code&·ec) | |
387 | ··{ | 384 | ··{ |
388 | ····if·(!ec) | 385 | ····acceptor_.async_accept( |
389 | ····{ | 386 | ········[this](const·std::error_code&·error,·tcp::socket·socket) |
390 | ······session->start(); | 387 | ········{ |
391 | ····} | 388 | ··········if·(!error) |
| 389 | ··········{ |
| 390 | ············std::make_shared<tcp_session>(std::move(socket),·channel_)->start(); |
| 391 | ··········} |
392 | | 392 | |
393 | ····start_accept(); | 393 | ··········accept(); |
| 394 | ········}); |
394 | ··} | 395 | ··} |
395 | | 396 | |
396 | private: | |
397 | ··asio::io_context&·io_context_; | 397 | ··asio::io_context&·io_context_; |
398 | ··tcp::acceptor·acceptor_; | 398 | ··tcp::acceptor·acceptor_; |
399 | ··channel·channel_; | 399 | ··channel·channel_; |
400 | }; | 400 | }; |
401 | | 401 | |
402 | //---------------------------------------------------------------------- | 402 | //---------------------------------------------------------------------- |
403 | | 403 | |
404 | int·main(int·argc,·char*·argv[]) | 404 | int·main(int·argc,·char*·argv[]) |
405 | { | 405 | { |
406 | ··try | 406 | ··try |
407 | ··{ | 407 | ··{ |
408 | ····using·namespace·std;·//·For·atoi. | 408 | ····using·namespace·std;·//·For·atoi. |
409 | | 409 | |
410 | ····if·(argc·!=·4) | 410 | ····if·(argc·!=·4) |
411 | ····{ | 411 | ····{ |
412 | ······std::cerr·<<·"Usage:·server·<listen_port>·<bcast_address>·<bcast_port>\n"; | 412 | ······std::cerr·<<·"Usage:·server·<listen_port>·<bcast_address>·<bcast_port>\n"; |
413 | ······return·1; | 413 | ······return·1; |
414 | ····} | 414 | ····} |
415 | | 415 | |
416 | ····asio::io_context·io_context; | 416 | ····asio::io_context·io_context; |
417 | | 417 | |
418 | ····tcp::endpoint·listen_endpoint(tcp::v4(),·atoi(argv[1])); | 418 | ····tcp::endpoint·listen_endpoint(tcp::v4(),·atoi(argv[1])); |
419 | | 419 | |
420 | ····udp::endpoint·broadcast_endpoint( | 420 | ····udp::endpoint·broadcast_endpoint( |
421 | ········asio::ip::make_address(argv[2]),·atoi(argv[3])); | 421 | ········asio::ip::make_address(argv[2]),·atoi(argv[3])); |
422 | | 422 | |
423 | ····server·s(io_context,·listen_endpoint,·broadcast_endpoint); | 423 | ····server·s(io_context,·listen_endpoint,·broadcast_endpoint); |
424 | | 424 | |
425 | ····io_context.run(); | 425 | ····io_context.run(); |
426 | ··} | 426 | ··} |
427 | ··catch·(std::exception&·e) | 427 | ··catch·(std::exception&·e) |
428 | ··{ | 428 | ··{ |
429 | ····std::cerr·<<·"Exception:·"·<<·e.what()·<<·"\n"; | 429 | ····std::cerr·<<·"Exception:·"·<<·e.what()·<<·"\n"; |
430 | ··} | 430 | ··} |
431 | | 431 | |
432 | ··return·0; | 432 | ··return·0; |
433 | } | 433 | } |