src/examples/cpp03/timeouts/async_tcp_client.cpp | src/examples/cpp11/timeouts/async_tcp_client.cpp |
⋮ | ⋮ |
1 | // | 1 | // |
2 | //·async_tcp_client.cpp | 2 | //·async_tcp_client.cpp |
3 | //·~~~~~~~~~~~~~~~~~~~~ | 3 | //·~~~~~~~~~~~~~~~~~~~~ |
4 | // | 4 | // |
5 | //·Copyright·(c)·2003-2018·Christopher·M.·Kohlhoff·(chris·at·kohlhoff·dot·com) | 5 | //·Copyright·(c)·2003-2018·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·"asio/buffer.hpp" | 11 | #include·"asio/buffer.hpp" |
12 | #include·"asio/io_context.hpp" | 12 | #include·"asio/io_context.hpp" |
13 | #include·"asio/ip/tcp.hpp" | 13 | #include·"asio/ip/tcp.hpp" |
14 | #include·"asio/read_until.hpp" | 14 | #include·"asio/read_until.hpp" |
15 | #include·"asio/steady_timer.hpp" | 15 | #include·"asio/steady_timer.hpp" |
16 | #include·"asio/write.hpp" | 16 | #include·"asio/write.hpp" |
17 | #include·<boost/bind.hpp> | 17 | #include·<functional> |
18 | #include·<iostream> | 18 | #include·<iostream> |
19 | #include·<string> | 19 | #include·<string> |
20 | | 20 | |
21 | using·asio::steady_timer; | 21 | using·asio::steady_timer; |
22 | using·asio::ip::tcp; | 22 | using·asio::ip::tcp; |
| 23 | using·std::placeholders::_1; |
| 24 | using·std::placeholders::_2; |
23 | | 25 | |
24 | // | 26 | // |
25 | //·This·class·manages·socket·timeouts·by·applying·the·concept·of·a·deadline. | 27 | //·This·class·manages·socket·timeouts·by·applying·the·concept·of·a·deadline. |
26 | //·Some·asynchronous·operations·are·given·deadlines·by·which·they·must·complete. | 28 | //·Some·asynchronous·operations·are·given·deadlines·by·which·they·must·complete. |
27 | //·Deadlines·are·enforced·by·an·"actor"·that·persists·for·the·lifetime·of·the | 29 | //·Deadlines·are·enforced·by·an·"actor"·that·persists·for·the·lifetime·of·the |
28 | //·client·object: | 30 | //·client·object: |
29 | // | 31 | // |
30 | //··+----------------+ | 32 | //··+----------------+ |
31 | //··|················| | 33 | //··|················| |
32 | //··|·check_deadline·|<---+ | 34 | //··|·check_deadline·|<---+ |
33 | //··|················|····| | 35 | //··|················|····| |
34 | //··+----------------+····|·async_wait() | 36 | //··+----------------+····|·async_wait() |
35 | //··············|·········| | 37 | //··············|·········| |
36 | //··············+---------+ | 38 | //··············+---------+ |
37 | // | 39 | // |
38 | //·If·the·deadline·actor·determines·that·the·deadline·has·expired,·the·socket | 40 | //·If·the·deadline·actor·determines·that·the·deadline·has·expired,·the·socket |
39 | //·is·closed·and·any·outstanding·operations·are·consequently·cancelled. | 41 | //·is·closed·and·any·outstanding·operations·are·consequently·cancelled. |
40 | // | 42 | // |
41 | //·Connection·establishment·involves·trying·each·endpoint·in·turn·until·a | 43 | //·Connection·establishment·involves·trying·each·endpoint·in·turn·until·a |
42 | //·connection·is·successful,·or·the·available·endpoints·are·exhausted.·If·the | 44 | //·connection·is·successful,·or·the·available·endpoints·are·exhausted.·If·the |
43 | //·deadline·actor·closes·the·socket,·the·connect·actor·is·woken·up·and·moves·to | 45 | //·deadline·actor·closes·the·socket,·the·connect·actor·is·woken·up·and·moves·to |
44 | //·the·next·endpoint. | 46 | //·the·next·endpoint. |
45 | // | 47 | // |
46 | //··+---------------+ | 48 | //··+---------------+ |
47 | //··|···············| | 49 | //··|···············| |
48 | //··|·start_connect·|<---+ | 50 | //··|·start_connect·|<---+ |
49 | //··|···············|····| | 51 | //··|···············|····| |
50 | //··+---------------+····| | 52 | //··+---------------+····| |
51 | //···········|···········| | 53 | //···········|···········| |
52 | //··async_-··|····+----------------+ | 54 | //··async_-··|····+----------------+ |
53 | //·connect()·|····|················| | 55 | //·connect()·|····|················| |
54 | //···········+--->|·handle_connect·| | 56 | //···········+--->|·handle_connect·| |
55 | //················|················| | 57 | //················|················| |
56 | //················+----------------+ | 58 | //················+----------------+ |
57 | //··························: | 59 | //··························: |
58 | //·Once·a·connection·is·····: | 60 | //·Once·a·connection·is·····: |
59 | //·made,·the·connect········: | 61 | //·made,·the·connect········: |
60 | //·actor·forks·in·two·-·····: | 62 | //·actor·forks·in·two·-·····: |
61 | //··························: | 63 | //··························: |
62 | //·an·actor·for·reading·····:·······and·an·actor·for | 64 | //·an·actor·for·reading·····:·······and·an·actor·for |
63 | //·inbound·messages:········:·······sending·heartbeats: | 65 | //·inbound·messages:········:·······sending·heartbeats: |
64 | //··························: | 66 | //··························: |
65 | //··+------------+··········:··········+-------------+ | 67 | //··+------------+··········:··········+-------------+ |
66 | //··|············|<-·-·-·-·-+-·-·-·-·->|·············| | 68 | //··|············|<-·-·-·-·-+-·-·-·-·->|·············| |
67 | //··|·start_read·|·····················|·start_write·|<---+ | 69 | //··|·start_read·|·····················|·start_write·|<---+ |
68 | //··|············|<---+················|·············|····| | 70 | //··|············|<---+················|·············|····| |
69 | //··+------------+····|················+-------------+····|·async_wait() | 71 | //··+------------+····|················+-------------+····|·async_wait() |
70 | //··········|·········|························|··········| | 72 | //··········|·········|························|··········| |
71 | //··async_-·|····+-------------+·······async_-·|····+--------------+ | 73 | //··async_-·|····+-------------+·······async_-·|····+--------------+ |
72 | //···read_-·|····|·············|·······write()·|····|··············| | 74 | //···read_-·|····|·············|·······write()·|····|··············| |
73 | //··until()·+--->|·handle_read·|···············+--->|·handle_write·| | 75 | //··until()·+--->|·handle_read·|···············+--->|·handle_write·| |
74 | //···············|·············|····················|··············| | 76 | //···············|·············|····················|··············| |
75 | //···············+-------------+····················+--------------+ | 77 | //···············+-------------+····················+--------------+ |
76 | // | 78 | // |
77 | //·The·input·actor·reads·messages·from·the·socket,·where·messages·are·delimited | 79 | //·The·input·actor·reads·messages·from·the·socket,·where·messages·are·delimited |
78 | //·by·the·newline·character.·The·deadline·for·a·complete·message·is·30·seconds. | 80 | //·by·the·newline·character.·The·deadline·for·a·complete·message·is·30·seconds. |
79 | // | 81 | // |
80 | //·The·heartbeat·actor·sends·a·heartbeat·(a·message·that·consists·of·a·single | 82 | //·The·heartbeat·actor·sends·a·heartbeat·(a·message·that·consists·of·a·single |
81 | //·newline·character)·every·10·seconds.·In·this·example,·no·deadline·is·applied | 83 | //·newline·character)·every·10·seconds.·In·this·example,·no·deadline·is·applied |
82 | //·to·message·sending. | 84 | //·to·message·sending. |
83 | // | 85 | // |
84 | class·client | 86 | class·client |
85 | { | 87 | { |
86 | public: | 88 | public: |
87 | ··client(asio::io_context&·io_context) | 89 | ··client(asio::io_context&·io_context) |
88 | ····:·stopped_(false), | 90 | ····:·socket_(io_context), |
89 | ······socket_(io_context), | |
90 | ······deadline_(io_context), | 91 | ······deadline_(io_context), |
91 | ······heartbeat_timer_(io_context) | 92 | ······heartbeat_timer_(io_context) |
92 | ··{ | 93 | ··{ |
93 | ··} | 94 | ··} |
94 | | 95 | |
95 | ··//·Called·by·the·user·of·the·client·class·to·initiate·the·connection·process. | 96 | ··//·Called·by·the·user·of·the·client·class·to·initiate·the·connection·process. |
96 | ··//·The·endpoints·will·have·been·obtained·using·a·tcp::resolver. | 97 | ··//·The·endpoints·will·have·been·obtained·using·a·tcp::resolver. |
97 | ··void·start(tcp::resolver::results_type·endpoints) | 98 | ··void·start(tcp::resolver::results_type·endpoints) |
98 | ··{ | 99 | ··{ |
99 | ····//·Start·the·connect·actor. | 100 | ····//·Start·the·connect·actor. |
100 | ····endpoints_·=·endpoints; | 101 | ····endpoints_·=·endpoints; |
101 | ····start_connect(endpoints_.begin()); | 102 | ····start_connect(endpoints_.begin()); |
102 | | 103 | |
103 | ····//·Start·the·deadline·actor.·You·will·note·that·we're·not·setting·any | 104 | ····//·Start·the·deadline·actor.·You·will·note·that·we're·not·setting·any |
104 | ····//·particular·deadline·here.·Instead,·the·connect·and·input·actors·will | 105 | ····//·particular·deadline·here.·Instead,·the·connect·and·input·actors·will |
105 | ····//·update·the·deadline·prior·to·each·asynchronous·operation. | 106 | ····//·update·the·deadline·prior·to·each·asynchronous·operation. |
106 | ····deadline_.async_wait(boost::bind(&client::check_deadline,·this)); | 107 | ····deadline_.async_wait(std::bind(&client::check_deadline,·this)); |
107 | ··} | 108 | ··} |
108 | | 109 | |
109 | ··//·This·function·terminates·all·the·actors·to·shut·down·the·connection.·It | 110 | ··//·This·function·terminates·all·the·actors·to·shut·down·the·connection.·It |
110 | ··//·may·be·called·by·the·user·of·the·client·class,·or·by·the·class·itself·in | 111 | ··//·may·be·called·by·the·user·of·the·client·class,·or·by·the·class·itself·in |
111 | ··//·response·to·graceful·termination·or·an·unrecoverable·error. | 112 | ··//·response·to·graceful·termination·or·an·unrecoverable·error. |
112 | ··void·stop() | 113 | ··void·stop() |
113 | ··{ | 114 | ··{ |
114 | ····stopped_·=·true; | 115 | ····stopped_·=·true; |
115 | ····asio::error_code·ignored_ec; | 116 | ····std::error_code·ignored_error; |
116 | ····socket_.close(ignored_ec); | 117 | ····socket_.close(ignored_error); |
117 | ····deadline_.cancel(); | 118 | ····deadline_.cancel(); |
118 | ····heartbeat_timer_.cancel(); | 119 | ····heartbeat_timer_.cancel(); |
119 | ··} | 120 | ··} |
120 | | 121 | |
121 | private: | 122 | private: |
122 | ··void·start_connect(tcp::resolver::results_type::iterator·endpoint_iter) | 123 | ··void·start_connect(tcp::resolver::results_type::iterator·endpoint_iter) |
123 | ··{ | 124 | ··{ |
124 | ····if·(endpoint_iter·!=·endpoints_.end()) | 125 | ····if·(endpoint_iter·!=·endpoints_.end()) |
125 | ····{ | 126 | ····{ |
126 | ······std::cout·<<·"Trying·"·<<·endpoint_iter->endpoint()·<<·"...\n"; | 127 | ······std::cout·<<·"Trying·"·<<·endpoint_iter->endpoint()·<<·"...\n"; |
127 | | 128 | |
128 | ······//·Set·a·deadline·for·the·connect·operation. | 129 | ······//·Set·a·deadline·for·the·connect·operation. |
129 | ······deadline_.expires_after(asio::chrono::seconds(60)); | 130 | ······deadline_.expires_after(std::chrono::seconds(60)); |
130 | | 131 | |
131 | ······//·Start·the·asynchronous·connect·operation. | 132 | ······//·Start·the·asynchronous·connect·operation. |
132 | ······socket_.async_connect(endpoint_iter->endpoint(), | 133 | ······socket_.async_connect(endpoint_iter->endpoint(), |
133 | ··········boost::bind(&client::handle_connect, | 134 | ··········std::bind(&client::handle_connect, |
134 | ············this,·_1,·endpoint_iter)); | 135 | ············this,·_1,·endpoint_iter)); |
135 | ····} | 136 | ····} |
136 | ····else | 137 | ····else |
137 | ····{ | 138 | ····{ |
138 | ······//·There·are·no·more·endpoints·to·try.·Shut·down·the·client. | 139 | ······//·There·are·no·more·endpoints·to·try.·Shut·down·the·client. |
139 | ······stop(); | 140 | ······stop(); |
140 | ····} | 141 | ····} |
141 | ··} | 142 | ··} |
142 | | 143 | |
143 | ··void·handle_connect(const·asio::error_code&·ec, | 144 | ··void·handle_connect(const·std::error_code&·error, |
144 | ······tcp::resolver::results_type::iterator·endpoint_iter) | 145 | ······tcp::resolver::results_type::iterator·endpoint_iter) |
145 | ··{ | 146 | ··{ |
146 | ····if·(stopped_) | 147 | ····if·(stopped_) |
147 | ······return; | 148 | ······return; |
148 | | 149 | |
149 | ····//·The·async_connect()·function·automatically·opens·the·socket·at·the·start | 150 | ····//·The·async_connect()·function·automatically·opens·the·socket·at·the·start |
150 | ····//·of·the·asynchronous·operation.·If·the·socket·is·closed·at·this·time·then | 151 | ····//·of·the·asynchronous·operation.·If·the·socket·is·closed·at·this·time·then |
151 | ····//·the·timeout·handler·must·have·run·first. | 152 | ····//·the·timeout·handler·must·have·run·first. |
152 | ····if·(!socket_.is_open()) | 153 | ····if·(!socket_.is_open()) |
153 | ····{ | 154 | ····{ |
154 | ······std::cout·<<·"Connect·timed·out\n"; | 155 | ······std::cout·<<·"Connect·timed·out\n"; |
155 | | 156 | |
156 | ······//·Try·the·next·available·endpoint. | 157 | ······//·Try·the·next·available·endpoint. |
157 | ······start_connect(++endpoint_iter); | 158 | ······start_connect(++endpoint_iter); |
158 | ····} | 159 | ····} |
159 | | 160 | |
160 | ····//·Check·if·the·connect·operation·failed·before·the·deadline·expired. | 161 | ····//·Check·if·the·connect·operation·failed·before·the·deadline·expired. |
161 | ····else·if·(ec) | 162 | ····else·if·(error) |
162 | ····{ | 163 | ····{ |
163 | ······std::cout·<<·"Connect·error:·"·<<·ec.message()·<<·"\n"; | 164 | ······std::cout·<<·"Connect·error:·"·<<·error.message()·<<·"\n"; |
164 | | 165 | |
165 | ······//·We·need·to·close·the·socket·used·in·the·previous·connection·attempt | 166 | ······//·We·need·to·close·the·socket·used·in·the·previous·connection·attempt |
166 | ······//·before·starting·a·new·one. | 167 | ······//·before·starting·a·new·one. |
167 | ······socket_.close(); | 168 | ······socket_.close(); |
168 | | 169 | |
169 | ······//·Try·the·next·available·endpoint. | 170 | ······//·Try·the·next·available·endpoint. |
170 | ······start_connect(++endpoint_iter); | 171 | ······start_connect(++endpoint_iter); |
171 | ····} | 172 | ····} |
172 | | 173 | |
173 | ····//·Otherwise·we·have·successfully·established·a·connection. | 174 | ····//·Otherwise·we·have·successfully·established·a·connection. |
174 | ····else | 175 | ····else |
175 | ····{ | 176 | ····{ |
176 | ······std::cout·<<·"Connected·to·"·<<·endpoint_iter->endpoint()·<<·"\n"; | 177 | ······std::cout·<<·"Connected·to·"·<<·endpoint_iter->endpoint()·<<·"\n"; |
177 | | 178 | |
178 | ······//·Start·the·input·actor. | 179 | ······//·Start·the·input·actor. |
179 | ······start_read(); | 180 | ······start_read(); |
180 | | 181 | |
181 | ······//·Start·the·heartbeat·actor. | 182 | ······//·Start·the·heartbeat·actor. |
182 | ······start_write(); | 183 | ······start_write(); |
183 | ····} | 184 | ····} |
184 | ··} | 185 | ··} |
185 | | 186 | |
186 | ··void·start_read() | 187 | ··void·start_read() |
187 | ··{ | 188 | ··{ |
188 | ····//·Set·a·deadline·for·the·read·operation. | 189 | ····//·Set·a·deadline·for·the·read·operation. |
189 | ····deadline_.expires_after(asio::chrono::seconds(30)); | 190 | ····deadline_.expires_after(std::chrono::seconds(30)); |
190 | | 191 | |
191 | ····//·Start·an·asynchronous·operation·to·read·a·newline-delimited·message. | 192 | ····//·Start·an·asynchronous·operation·to·read·a·newline-delimited·message. |
192 | ····asio::async_read_until(socket_, | 193 | ····asio::async_read_until(socket_, |
193 | ········asio::dynamic_buffer(input_buffer_),·'\n', | 194 | ········asio::dynamic_buffer(input_buffer_),·'\n', |
194 | ········boost::bind(&client::handle_read,·this,·_1,·_2)); | 195 | ········std::bind(&client::handle_read,·this,·_1,·_2)); |
195 | ··} | 196 | ··} |
196 | | 197 | |
197 | ··void·handle_read(const·asio::error_code&·ec,·std::size_t·n) | 198 | ··void·handle_read(const·std::error_code&·error,·std::size_t·n) |
198 | ··{ | 199 | ··{ |
199 | ····if·(stopped_) | 200 | ····if·(stopped_) |
200 | ······return; | 201 | ······return; |
201 | | 202 | |
202 | ····if·(!ec) | 203 | ····if·(!error) |
203 | ····{ | 204 | ····{ |
204 | ······//·Extract·the·newline-delimited·message·from·the·buffer. | 205 | ······//·Extract·the·newline-delimited·message·from·the·buffer. |
205 | ······std::string·line(input_buffer_.substr(0,·n·-·1)); | 206 | ······std::string·line(input_buffer_.substr(0,·n·-·1)); |
206 | ······input_buffer_.erase(0,·n); | 207 | ······input_buffer_.erase(0,·n); |
207 | | 208 | |
208 | ······//·Empty·messages·are·heartbeats·and·so·ignored. | 209 | ······//·Empty·messages·are·heartbeats·and·so·ignored. |
209 | ······if·(!line.empty()) | 210 | ······if·(!line.empty()) |
210 | ······{ | 211 | ······{ |
211 | ········std::cout·<<·"Received:·"·<<·line·<<·"\n"; | 212 | ········std::cout·<<·"Received:·"·<<·line·<<·"\n"; |
212 | ······} | 213 | ······} |
213 | | 214 | |
214 | ······start_read(); | 215 | ······start_read(); |
215 | ····} | 216 | ····} |
216 | ····else | 217 | ····else |
217 | ····{ | 218 | ····{ |
218 | ······std::cout·<<·"Error·on·receive:·"·<<·ec.message()·<<·"\n"; | 219 | ······std::cout·<<·"Error·on·receive:·"·<<·error.message()·<<·"\n"; |
219 | | 220 | |
220 | ······stop(); | 221 | ······stop(); |
221 | ····} | 222 | ····} |
222 | ··} | 223 | ··} |
223 | | 224 | |
224 | ··void·start_write() | 225 | ··void·start_write() |
225 | ··{ | 226 | ··{ |
226 | ····if·(stopped_) | 227 | ····if·(stopped_) |
227 | ······return; | 228 | ······return; |
228 | | 229 | |
229 | ····//·Start·an·asynchronous·operation·to·send·a·heartbeat·message. | 230 | ····//·Start·an·asynchronous·operation·to·send·a·heartbeat·message. |
230 | ····asio::async_write(socket_,·asio::buffer("\n",·1), | 231 | ····asio::async_write(socket_,·asio::buffer("\n",·1), |
231 | ········boost::bind(&client::handle_write,·this,·_1)); | 232 | ········std::bind(&client::handle_write,·this,·_1)); |
232 | ··} | 233 | ··} |
233 | | 234 | |
234 | ··void·handle_write(const·asio::error_code&·ec) | 235 | ··void·handle_write(const·std::error_code&·error) |
235 | ··{ | 236 | ··{ |
236 | ····if·(stopped_) | 237 | ····if·(stopped_) |
237 | ······return; | 238 | ······return; |
238 | | 239 | |
239 | ····if·(!ec) | 240 | ····if·(!error) |
240 | ····{ | 241 | ····{ |
241 | ······//·Wait·10·seconds·before·sending·the·next·heartbeat. | 242 | ······//·Wait·10·seconds·before·sending·the·next·heartbeat. |
242 | ······heartbeat_timer_.expires_after(asio::chrono::seconds(10)); | 243 | ······heartbeat_timer_.expires_after(std::chrono::seconds(10)); |
243 | ······heartbeat_timer_.async_wait(boost::bind(&client::start_write,·this)); | 244 | ······heartbeat_timer_.async_wait(std::bind(&client::start_write,·this)); |
244 | ····} | 245 | ····} |
245 | ····else | 246 | ····else |
246 | ····{ | 247 | ····{ |
247 | ······std::cout·<<·"Error·on·heartbeat:·"·<<·ec.message()·<<·"\n"; | 248 | ······std::cout·<<·"Error·on·heartbeat:·"·<<·error.message()·<<·"\n"; |
248 | | 249 | |
249 | ······stop(); | 250 | ······stop(); |
250 | ····} | 251 | ····} |
251 | ··} | 252 | ··} |
252 | | 253 | |
253 | ··void·check_deadline() | 254 | ··void·check_deadline() |
254 | ··{ | 255 | ··{ |
255 | ····if·(stopped_) | 256 | ····if·(stopped_) |
256 | ······return; | 257 | ······return; |
257 | | 258 | |
258 | ····//·Check·whether·the·deadline·has·passed.·We·compare·the·deadline·against | 259 | ····//·Check·whether·the·deadline·has·passed.·We·compare·the·deadline·against |
259 | ····//·the·current·time·since·a·new·asynchronous·operation·may·have·moved·the | 260 | ····//·the·current·time·since·a·new·asynchronous·operation·may·have·moved·the |
260 | ····//·deadline·before·this·actor·had·a·chance·to·run. | 261 | ····//·deadline·before·this·actor·had·a·chance·to·run. |
261 | ····if·(deadline_.expiry()·<=·steady_timer::clock_type::now()) | 262 | ····if·(deadline_.expiry()·<=·steady_timer::clock_type::now()) |
262 | ····{ | 263 | ····{ |
263 | ······//·The·deadline·has·passed.·The·socket·is·closed·so·that·any·outstanding | 264 | ······//·The·deadline·has·passed.·The·socket·is·closed·so·that·any·outstanding |
264 | ······//·asynchronous·operations·are·cancelled. | 265 | ······//·asynchronous·operations·are·cancelled. |
265 | ······socket_.close(); | 266 | ······socket_.close(); |
266 | | 267 | |
267 | ······//·There·is·no·longer·an·active·deadline.·The·expiry·is·set·to·the | 268 | ······//·There·is·no·longer·an·active·deadline.·The·expiry·is·set·to·the |
268 | ······//·maximum·time·point·so·that·the·actor·takes·no·action·until·a·new | 269 | ······//·maximum·time·point·so·that·the·actor·takes·no·action·until·a·new |
269 | ······//·deadline·is·set. | 270 | ······//·deadline·is·set. |
270 | ······deadline_.expires_at(steady_timer::time_point::max()); | 271 | ······deadline_.expires_at(steady_timer::time_point::max()); |
271 | ····} | 272 | ····} |
272 | | 273 | |
273 | ····//·Put·the·actor·back·to·sleep. | 274 | ····//·Put·the·actor·back·to·sleep. |
274 | ····deadline_.async_wait(boost::bind(&client::check_deadline,·this)); | 275 | ····deadline_.async_wait(std::bind(&client::check_deadline,·this)); |
275 | ··} | 276 | ··} |
276 | | 277 | |
277 | private: | 278 | private: |
278 | ··bool·stopped_; | 279 | ··bool·stopped_·=·false; |
279 | ··tcp::resolver::results_type·endpoints_; | 280 | ··tcp::resolver::results_type·endpoints_; |
280 | ··tcp::socket·socket_; | 281 | ··tcp::socket·socket_; |
281 | ··std::string·input_buffer_; | 282 | ··std::string·input_buffer_; |
282 | ··steady_timer·deadline_; | 283 | ··steady_timer·deadline_; |
283 | ··steady_timer·heartbeat_timer_; | 284 | ··steady_timer·heartbeat_timer_; |
284 | }; | 285 | }; |
285 | | 286 | |
286 | int·main(int·argc,·char*·argv[]) | 287 | int·main(int·argc,·char*·argv[]) |
287 | { | 288 | { |
288 | ··try | 289 | ··try |
289 | ··{ | 290 | ··{ |
290 | ····if·(argc·!=·3) | 291 | ····if·(argc·!=·3) |
291 | ····{ | 292 | ····{ |
292 | ······std::cerr·<<·"Usage:·client·<host>·<port>\n"; | 293 | ······std::cerr·<<·"Usage:·client·<host>·<port>\n"; |
293 | ······return·1; | 294 | ······return·1; |
294 | ····} | 295 | ····} |
295 | | 296 | |
296 | ····asio::io_context·io_context; | 297 | ····asio::io_context·io_context; |
297 | ····tcp::resolver·r(io_context); | 298 | ····tcp::resolver·r(io_context); |
298 | ····client·c(io_context); | 299 | ····client·c(io_context); |
299 | | 300 | |
300 | ····c.start(r.resolve(argv[1],·argv[2])); | 301 | ····c.start(r.resolve(argv[1],·argv[2])); |
301 | | 302 | |
302 | ····io_context.run(); | 303 | ····io_context.run(); |
303 | ··} | 304 | ··} |
304 | ··catch·(std::exception&·e) | 305 | ··catch·(std::exception&·e) |
305 | ··{ | 306 | ··{ |
306 | ····std::cerr·<<·"Exception:·"·<<·e.what()·<<·"\n"; | 307 | ····std::cerr·<<·"Exception:·"·<<·e.what()·<<·"\n"; |
307 | ··} | 308 | ··} |
308 | | 309 | |
309 | ··return·0; | 310 | ··return·0; |
310 | } | 311 | } |