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

◆ Request

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

Definition at line 64 of file clients.h.

◆ Response

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

Definition at line 65 of file clients.h.

◆ SocketConnection

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

Definition at line 66 of file clients.h.

◆ WebApp

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

Definition at line 54 of file servers.h.

Function Documentation

◆ getClient()

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

Definition at line 68 of file clients.h.

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

◆ getWebApp()

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

Definition at line 57 of file servers.h.

57 {
58 WebApp webApp = WebApp(name, getRouter());
59
60 return webApp;
61 }
getRouter
static express::Router getRouter()
Definition servers.h:46
apps::http::legacy::WebApp
express::legacy::NET::WebApp WebApp
Definition servers.h:54