SNode.C
Loading...
Searching...
No Matches
apps::http::legacy Namespace Reference

Typedefs

using Client = web::http::legacy::NET::Client
using MasterRequest = Client::MasterRequest
using Request = Client::Request
using Response = Client::Response
using SocketConnection = Client::SocketConnection
using WebApp = express::legacy::NET::WebApp

Functions

Client getClient ()
static WebApp getWebApp (const std::string &name)

Typedef Documentation

◆ Client

using apps::http::legacy::Client = web::http::legacy::NET::Client

Definition at line 90 of file clients.h.

◆ MasterRequest

using apps::http::legacy::MasterRequest = Client::MasterRequest

Definition at line 91 of file clients.h.

◆ Request

using apps::http::legacy::Request = Client::Request

Definition at line 92 of file clients.h.

◆ Response

using apps::http::legacy::Response = Client::Response

Definition at line 93 of file clients.h.

◆ SocketConnection

typedef WebApp::SocketConnection apps::http::legacy::SocketConnection = Client::SocketConnection

Definition at line 94 of file clients.h.

◆ WebApp

using apps::http::legacy::WebApp = express::legacy::NET::WebApp

Definition at line 76 of file servers.h.

Function Documentation

◆ getClient()

Client apps::http::legacy::getClient ( )
inline

Definition at line 96 of file clients.h.

96 {
97 Client client(
98 "httpclient",
99 [](const std::shared_ptr<MasterRequest>& req) {
100 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName() << ": OnRequestStart";
101
102 req->httpMajor = 1;
103 req->httpMinor = 1;
104 req->url = "/";
105 req->set("Connection", "keep-alive");
106 req->setTrailer("MyTrailer",
107 "MyTrailerValue"); // The "Trailer" header field should be populated but the Trailer itself should not be
108 // send here because there is no content which is send using "Transfer-Encoding:chunked"
109 req->end(
110 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
111 logResponse(req, res);
112 },
113 [](const std::shared_ptr<Request>&, const std::string&) {
114 });
115
116 req->httpMinor = 1;
117 req->method = "GET";
118 req->url = "/sendfile/";
119 req->set("Connection", "keep-alive");
120 req->sendFile(
121 "/home/voc/projects/snodec/snode.c/CMakeLists.tt",
122 [req](int ret) {
123 if (ret == 0) {
124 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
125 << " HTTP: Request accepted: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
126 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.tt";
127 } else {
128 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
129 << " HTTP: Request failed: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
130 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.tt";
131 }
132 },
133 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
134 logResponse(req, res);
135 },
136 [](const std::shared_ptr<Request>&, const std::string&) {
137 });
138
139 req->init();
140 req->httpMinor = 1;
141 req->url = "/third";
142 req->set("Connection", "keep-alive");
143 req->setTrailer("MyTrailer",
144 "MyTrailerValue"); // The "Trailer" header field should be populated but the Trailer itself should not be
145 // send here because there is no content which is send using "Transfer-Encoding:chunked"
146 req->end(
147 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
148 logResponse(req, res);
149 },
150 [](const std::shared_ptr<Request>&, const std::string&) {
151 });
152
153#define LONG
154#ifdef LONG
155 req->url = "/";
156 req->set("Connection", "keep-alive");
157 req->end(
158 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
159 logResponse(req, res);
160 },
161 [](const std::shared_ptr<Request>&, const std::string&) {
162 });
163
164 req->httpMinor = 1;
165 req->url = "/index.html";
166 // req->set("Connection", "keep-alive");
167 req->end(
168 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
169 logResponse(req, res);
170 },
171 [](const std::shared_ptr<Request>&, const std::string&) {
172 });
173 req->url = "/";
174 req->set("Connection", "keep-alive");
175 req->end(
176 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
177 logResponse(req, res);
178 },
179 [req](const std::shared_ptr<Request>&, const std::string&) {
180 });
181 req->url = "/index.html";
182 req->set("Connection", "keep-alive");
183 req->end(
184 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
185 logResponse(req, res);
186 },
187 [req](const std::shared_ptr<Request>&, const std::string&) {
188 });
189 req->url = "/";
190 req->set("Connection", "keep-alive");
191 req->end(
192 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
193 logResponse(req, res);
194 },
195 [req](const std::shared_ptr<Request>&, const std::string&) {
196 });
197 req->url = "/index.html";
198 req->set("Connection", "keep-alive");
199 req->end(
200 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
201 logResponse(req, res);
202 },
203 [req](const std::shared_ptr<Request>&, const std::string&) {
204 });
205 req->url = "/";
206 req->set("Connection", "keep-alive");
207 req->end(
208 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
209 logResponse(req, res);
210 },
211 [req](const std::shared_ptr<Request>&, const std::string&) {
212 });
213 req->url = "/index.html";
214 req->set("Connection", "keep-alive");
215 req->end(
216 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
217 logResponse(req, res);
218 },
219 [req](const std::shared_ptr<Request>&, const std::string&) {
220 });
221 req->url = "/";
222 req->set("Connection", "keep-alive");
223 req->end(
224 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
225 logResponse(req, res);
226 },
227 [req](const std::shared_ptr<Request>&, const std::string&) {
228 });
229 req->url = "/index.html";
230 req->set("Connection", "keep-alive");
231 req->end(
232 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
233 logResponse(req, res);
234 },
235 [req](const std::shared_ptr<Request>&, const std::string&) {
236 });
237 req->url = "/";
238 req->set("Connection", "keep-alive");
239 req->end(
240 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
241 logResponse(req, res);
242 },
243 [req](const std::shared_ptr<Request>&, const std::string&) {
244 });
245 req->url = "/index.html";
246 req->set("Connection", "keep-alive");
247 req->end(
248 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
249 logResponse(req, res);
250 },
251 [req](const std::shared_ptr<Request>&, const std::string&) {
252 });
253 req->url = "/";
254 req->set("Connection", "keep-alive");
255 req->end(
256 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
257 logResponse(req, res);
258 },
259 [req](const std::shared_ptr<Request>&, const std::string&) {
260 });
261 req->url = "/index.html";
262 req->set("Connection", "keep-alive");
263 req->end(
264 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
265 logResponse(req, res);
266 },
267 [req](const std::shared_ptr<Request>&, const std::string&) {
268 });
269 req->url = "/";
270 req->set("Connection", "keep-alive");
271 req->end(
272 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
273 logResponse(req, res);
274 },
275 [req](const std::shared_ptr<Request>&, const std::string&) {
276 });
277 req->url = "/index.html";
278 req->set("Connection", "keep-alive");
279 req->end(
280 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
281 logResponse(req, res);
282 },
283 [req](const std::shared_ptr<Request>&, const std::string&) {
284 });
285 req->url = "/";
286 req->set("Connection", "close");
287 req->end(
288 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
289 logResponse(req, res);
290 },
291 [req](const std::shared_ptr<Request>&, const std::string&) {
292 });
293
294 const std::shared_ptr<web::http::client::tools::EventSource> eventStream_1 =
295 web::http::legacy::NET::EventSource("http://" + req->hostFieldValue, "/sse?hihi=3");
296
297 if (eventStream_1) {
298 eventStream_1->onOpen([]() {
299 VLOG(0) << "OnOpen 1";
300 });
301
302 eventStream_1->onError([]() {
303 VLOG(0) << "OnError 1";
304 });
305
306 eventStream_1->onMessage([](const web::http::client::tools::EventSource::MessageEvent& message) {
307 VLOG(0) << "OnMessage 1:1: " << message.data;
308 });
309 eventStream_1->onMessage([](const web::http::client::tools::EventSource::MessageEvent& message) {
310 VLOG(0) << "OnMessage 1:2: " << message.data;
311 });
312 eventStream_1->addEventListener("myevent", [](const web::http::client::tools::EventSource::MessageEvent& message) {
313 VLOG(0) << "EventListener for 'myevent' 1:1: " << message.lastEventId << " : " << message.data;
314 });
315 eventStream_1->addEventListener("myevent", [](const web::http::client::tools::EventSource::MessageEvent& message) {
316 VLOG(0) << "EventListener for 'myevent' 1:2: " << message.lastEventId << " : " << message.data;
317 });
318
319 core::timer::Timer::singleshotTimer(
320 [eventStream_1]() {
321 eventStream_1->close();
322 },
323 5);
324 }
325
326 auto eventStream_2 = web::http::legacy::NET::EventSource("http://localhost:8080/sse");
327
328 if (eventStream_2) {
329 eventStream_2->onOpen([]() {
330 VLOG(0) << "OnOpen 2";
331 });
332
333 eventStream_2->onError([]() {
334 VLOG(0) << "OnError 2";
335 });
336
337 eventStream_2->onMessage([](const web::http::client::tools::EventSource::MessageEvent& message) {
338 VLOG(0) << "OnMessage 2:1: " << message.data;
339 });
340 eventStream_2->onMessage([](const web::http::client::tools::EventSource::MessageEvent& message) {
341 VLOG(0) << "OnMessage 2:2: " << message.data;
342 });
343 eventStream_2->addEventListener("myevent", [](const web::http::client::tools::EventSource::MessageEvent& message) {
344 VLOG(0) << "EventListener for 'myevent' 2:1: " << message.lastEventId << " : " << message.data;
345 });
346 eventStream_2->addEventListener("myevent", [](const web::http::client::tools::EventSource::MessageEvent& message) {
347 VLOG(0) << "EventListener for 'myevent' 2:2: " << message.lastEventId << " : " << message.data;
348 });
349 }
350
351 /*
352 req->httpMinor = 1;
353 req->method = "GET";
354 req->url = "/";
355 req->set("Test", "aaa");
356 req->setTrailer("MyTrailer1",
357 "MyTrailerValue1"); // Full trailer processing. Header field "Trailer" set and the Trailer itself is also
358 // sent because here content will be sent with "Transfer-Encoding:chunked"
359 req->setTrailer("MyTrailer2", "MyTrailerValue2");
360 req->setTrailer("MyTrailer3", "MyTrailerValue3");
361 req->setTrailer("MyTrailer4", "MyTrailerValue4");
362 req->setTrailer("MyTrailer5", "MyTrailerValue5");
363 req->setTrailer("MyTrailer6", "MyTrailerValue6");
364 req->query("Query1", "QueryValue1");
365 req->query("Query2", "QueryValue2");
366 req->sendFile(
367 "/home/voc/projects/snodec/snode.c/CMakeLists.txt",
368 [req](int ret) {
369 if (ret == 0) {
370 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
371 << " HTTP: Request accepted: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
372 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
373 } else {
374 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
375 << " HTTP: Request failed: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
376 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
377 }
378 },
379 [&req](const std::shared_ptr<Request>& reqa, const std::shared_ptr<Response>& res) {
380 logResponse(reqa, res);
381
382 req->method = "GET";
383 req->url = "/sdfsdf";
384 req->set("Connection", "close");
385 req->set("Test", "bbb");
386 req->sendFile(
387 "/home/voc/projects/snodec/snode.c/CMakeLists.txt",
388 [&req](int ret) {
389 if (ret == 0) {
390 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
391 << " HTTP: Request accepted: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
392 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
393 } else {
394 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
395 << " HTTP: Request failed: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
396 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
397 }
398 },
399 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
400 logResponse(req, res);
401 },
402 [req](const std::shared_ptr<Request>&, const std::string&) {
403 });
404 },
405 [req](const std::shared_ptr<Request>&, const std::string&) {
406 });
407 req->method = "GET";
408 req->url = "/";
409 // req->set("Connection", "close");
410 req->set("Test", "xxx");
411 req->end(
412 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
413 logResponse(req, res);
414 },
415 [req](const std::shared_ptr<Request>&, const std::string&) {
416 });
417 core::EventReceiver::atNextTick([&req]() {
418 req->method = "GET";
419 req->url = "/";
420 req->set("Connection", "keep-alive");
421 req->set("Test", "ddd");
422 req->sendFile(
423 "/home/voc/projects/snodec/snode.c/CMakeLists.txt",
424 [req](int ret) {
425 if (ret == 0) {
426 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
427 << " HTTP: Request accepted: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
428 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
429 } else {
430 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
431 << " HTTP: Request failed: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
432 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
433 }
434 },
435 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
436 logResponse(req, res);
437 },
438 [req](const std::shared_ptr<Request>&, const std::string&) {
439 });
440
441 req->method = "GET";
442 req->url = "/";
443 req->set("Connection", "keep-alive");
444 req->set("Test", "eee");
445 req->setTrailer("MyTrailer1", "MyTrailerValue1");
446 req->setTrailer("MyTrailer2", "MyTrailerValue2");
447 req->sendFile(
448 "/home/voc/projects/snodec/snode.c/CMakeLists.txt",
449 [req](int ret) {
450 if (ret == 0) {
451 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
452 << " HTTP: Request accepted: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
453 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
454 } else {
455 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
456 << " HTTP: Request failed: GET / HTTP/" << req->httpMajor << "." << req->httpMinor;
457 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
458 }
459 },
460 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
461 logResponse(req, res);
462 },
463 [req](const std::shared_ptr<Request>&, const std::string&) {
464 });
465 });
466 */
467#endif
468 },
469 []([[maybe_unused]] const std::shared_ptr<Request>& req) {
470 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName() << ": OnRequestEnd";
471 });
472
473 client.setOnConnect([](SocketConnection* socketConnection) { // onConnect
474 VLOG(1) << socketConnection->getConnectionName() << ": OnConnect";
475
476 VLOG(1) << "\tLocal: " << socketConnection->getLocalAddress().toString();
477 VLOG(1) << "\tPeer: " << socketConnection->getRemoteAddress().toString();
478 });
479
480 client.setOnDisconnect([](SocketConnection* socketConnection) { // onDisconnect
481 VLOG(1) << socketConnection->getConnectionName() << ": OnDisconnect";
482
483 VLOG(1) << "\tLocal: " << socketConnection->getLocalAddress().toString();
484 VLOG(1) << "\tPeer: " << socketConnection->getRemoteAddress().toString();
485 });
486
487 return client;
488 }
LOG
#define LOG(level)
Definition Logger.h:148
PLOG
#define PLOG(level)
Definition Logger.h:152
VLOG
#define VLOG(level)
Definition Logger.h:164
core::timer::Timer::singleshotTimer
static Timer singleshotTimer(const std::function< void()> &dispatcher, const utils::Timeval &timeout)
Definition Timer.cpp:57
logResponse
static void logResponse(const std::shared_ptr< web::http::client::Request > &req, const std::shared_ptr< web::http::client::Response > &res)
Definition clients.h:71
apps::http::legacy::SocketConnection
Client::SocketConnection SocketConnection
Definition clients.h:94
apps::http::legacy::Client
web::http::legacy::NET::Client Client
Definition clients.h:90

References logger::ERROR, and logger::LogMessage::LogMessage().

Here is the call graph for this function:

◆ getWebApp()

WebApp apps::http::legacy::getWebApp ( const std::string & name)
static

Definition at line 79 of file servers.h.

79 {
80 WebApp webApp(name, getRouter());
81
82 return webApp;
83 }
getRouter
static express::Router getRouter()
Definition servers.h:68
apps::http::legacy::WebApp
express::legacy::NET::WebApp WebApp
Definition servers.h:76

References getRouter().

Here is the call graph for this function: