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

Typedefs

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

Functions

static 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 85 of file clients.h.

◆ Request

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

Definition at line 86 of file clients.h.

◆ Response

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

Definition at line 87 of file clients.h.

◆ SocketConnection

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

Definition at line 88 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()

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

Definition at line 90 of file clients.h.

90 {
91 Client client(
92 "httpclient",
93 [](const std::shared_ptr<Request>& req) {
94 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName() << ": OnRequestStart";
95
96 req->httpMinor = 0;
97 req->url = "/";
98 req->set("Connection", "keep-alive");
99 req->setTrailer("MyTrailer",
100 "MyTrailerValue"); // The "Trailer" header field should be populated but the Trailer itself should not be
101 // send here because there is no content which is send using "Transfer-Encoding:chunked"
102 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
103 logResponse(req, res);
104 });
105#define LONG
106#ifdef LONG
107 req->url = "/hihihih";
108 req->set("Connection", "keep-alive");
109 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
110 logResponse(req, res);
111 });
112
113 req->httpMinor = 1;
114 req->url = "/index.html";
115 // req->set("Connection", "keep-alive");
116 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
117 logResponse(req, res);
118 });
119 req->url = "/";
120 req->set("Connection", "keep-alive");
121 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
122 logResponse(req, res);
123 });
124 req->url = "/index.html";
125 req->set("Connection", "keep-alive");
126 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
127 logResponse(req, res);
128 });
129 req->url = "/";
130 req->set("Connection", "keep-alive");
131 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
132 logResponse(req, res);
133 });
134 req->url = "/index.html";
135 req->set("Connection", "keep-alive");
136 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
137 logResponse(req, res);
138 });
139 req->url = "/";
140 req->set("Connection", "keep-alive");
141 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
142 logResponse(req, res);
143 });
144 req->url = "/index.html";
145 req->set("Connection", "keep-alive");
146 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
147 logResponse(req, res);
148 });
149 req->url = "/";
150 req->set("Connection", "keep-alive");
151 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
152 logResponse(req, res);
153 });
154 req->url = "/index.html";
155 req->set("Connection", "keep-alive");
156 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
157 logResponse(req, res);
158 });
159 req->url = "/";
160 req->set("Connection", "keep-alive");
161 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
162 logResponse(req, res);
163 });
164 req->url = "/index.html";
165 req->set("Connection", "keep-alive");
166 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
167 logResponse(req, res);
168 });
169 req->url = "/";
170 req->set("Connection", "keep-alive");
171 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
172 logResponse(req, res);
173 });
174 req->url = "/index.html";
175 req->set("Connection", "keep-alive");
176 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
177 logResponse(req, res);
178 });
179 req->url = "/";
180 req->set("Connection", "keep-alive");
181 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
182 logResponse(req, res);
183 });
184 req->url = "/index.html";
185 req->set("Connection", "keep-alive");
186 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
187 logResponse(req, res);
188 });
189 req->url = "/";
190 req->set("Connection", "keep-alive");
191 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
192 logResponse(req, res);
193 });
194
195 req->httpMinor = 1;
196 req->method = "POST";
197 req->url = "/";
198 req->set("Test", "aaa");
199 req->setTrailer("MyTrailer1",
200 "MyTrailerValue1"); // Full trailer processing. Header field "Trailer" set and the Trailer itself is also
201 // sent because here content will be sent with "Transfer-Encoding:chunked"
202 req->setTrailer("MyTrailer2", "MyTrailerValue2");
203 req->setTrailer("MyTrailer3", "MyTrailerValue3");
204 req->setTrailer("MyTrailer4", "MyTrailerValue4");
205 req->setTrailer("MyTrailer5", "MyTrailerValue5");
206 req->setTrailer("MyTrailer6", "MyTrailerValue6");
207 req->query("Query1", "QueryValue1");
208 req->query("Query2", "QueryValue2");
209 req->sendFile(
210 "/home/voc/projects/snodec/snode.c/CMakeLists.txt",
211 [req](int ret) {
212 if (ret == 0) {
213 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
214 << " HTTP: Request accepted: POST / HTTP/" << req->httpMajor << "." << req->httpMinor;
215 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
216 } else {
217 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
218 << " HTTP: Request failed: POST / HTTP/" << req->httpMajor << "." << req->httpMinor;
219 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
220
221 req->set("Connection", "close");
222 req->end([]([[maybe_unused]] const std::shared_ptr<Request>& req,
223 [[maybe_unused]] const std::shared_ptr<Response>& res) {
224 });
225 }
226 },
227 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
228 logResponse(req, res);
229
230 req->init();
231 req->method = "POST";
232 req->url = "/";
233 req->set("Connection", "keep-alive");
234 req->set("Test", "bbb");
235 req->sendFile(
236 "/home/voc/projects/snodec/snode.c/CMakeLists.tt",
237 [req](int ret) {
238 if (ret == 0) {
239 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
240 << " HTTP: Request accepted: POST / HTTP/" << req->httpMajor << "." << req->httpMinor;
241 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.tt";
242 } else {
243 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
244 << " HTTP: Request failed: POST / HTTP/" << req->httpMajor << "." << req->httpMinor;
245 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.tt";
246
247 req->init();
248 req->method = "GET";
249 req->url = "/";
250 req->set("Connection", "close");
251 req->set("Test", "ccc");
252 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
253 logResponse(req, res);
254 });
255 }
256 },
257 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
258 logResponse(req, res);
259 });
260 });
261 req->init();
262 req->method = "GET";
263 req->url = "/";
264 req->set("Connection", "close");
265 req->set("Test", "xxx");
266 req->end([](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
267 logResponse(req, res);
268 });
269 core::EventReceiver::atNextTick([req]() {
270 req->method = "POST";
271 req->url = "/";
272 req->set("Connection", "keep-alive");
273 req->set("Test", "ddd");
274 req->sendFile(
275 "/home/voc/projects/snodec/snode.c/CMakeLists.txt",
276 [req](int ret) {
277 if (ret == 0) {
278 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
279 << " HTTP: Request accepted: POST / HTTP/" << req->httpMajor << "." << req->httpMinor;
280 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
281 } else {
282 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
283 << " HTTP: Request failed: POST / HTTP/" << req->httpMajor << "." << req->httpMinor;
284 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
285
286 req->set("Connection", "close");
287 req->end([]([[maybe_unused]] const std::shared_ptr<Request>& req,
288 [[maybe_unused]] const std::shared_ptr<Response>& res) {
289 });
290 }
291 },
292 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
293 logResponse(req, res);
294 });
295
296 req->method = "POST";
297 req->url = "/";
298 req->set("Connection", "keep-alive");
299 req->set("Test", "eee");
300 req->setTrailer("MyTrailer1", "MyTrailerValue1");
301 req->setTrailer("MyTrailer2", "MyTrailerValue2");
302 req->sendFile(
303 "/home/voc/projects/snodec/snode.c/CMakeLists.txt",
304 [req](int ret) {
305 if (ret == 0) {
306 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName()
307 << " HTTP: Request accepted: POST / HTTP/" << req->httpMajor << "." << req->httpMinor;
308 VLOG(1) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
309 } else {
310 LOG(ERROR) << req->getSocketContext()->getSocketConnection()->getConnectionName()
311 << " HTTP: Request failed: POST / HTTP/" << req->httpMajor << "." << req->httpMinor;
312 PLOG(ERROR) << " /home/voc/projects/snodec/snode.c/CMakeLists.txt";
313
314 req->set("Connection", "close");
315 req->end([]([[maybe_unused]] const std::shared_ptr<Request>& req,
316 [[maybe_unused]] const std::shared_ptr<Response>& res) {
317 });
318 }
319 },
320 [](const std::shared_ptr<Request>& req, const std::shared_ptr<Response>& res) {
321 logResponse(req, res);
322 });
323 });
324#endif
325 },
326 []([[maybe_unused]] const std::shared_ptr<Request>& req) {
327 VLOG(1) << req->getSocketContext()->getSocketConnection()->getConnectionName() << ": OnRequestEnd";
328 });
329
330 client.setOnConnect([](SocketConnection* socketConnection) { // onConnect
331 VLOG(1) << socketConnection->getConnectionName() << ": OnConnect";
332
333 VLOG(1) << "\tLocal: " << socketConnection->getLocalAddress().toString();
334 VLOG(1) << "\tPeer: " << socketConnection->getRemoteAddress().toString();
335 });
336
337 client.setOnDisconnect([](SocketConnection* socketConnection) { // onDisconnect
338 VLOG(1) << socketConnection->getConnectionName() << ": OnDisconnect";
339
340 VLOG(1) << "\tLocal: " << socketConnection->getLocalAddress().toString();
341 VLOG(1) << "\tPeer: " << socketConnection->getRemoteAddress().toString();
342 });
343
344 return client;
345 }
core::EventReceiver::atNextTick
static void atNextTick(const std::function< void(void)> &callBack)
Definition EventReceiver.cpp:50
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:67
apps::http::legacy::Client
web::http::legacy::NET::Client Client
Definition clients.h:85

◆ getWebApp()

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

Definition at line 79 of file servers.h.

79 {
80 WebApp 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