1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
/* We simply call the root header file "App.h", giving you uWS::App and uWS::SSLApp */
#include "App.h"
/* This is a simple WebSocket "async" upgrade example.
* You may compile it with "WITH_OPENSSL=1 make" or with "make" */
int main() {
/* ws->getUserData returns one of these */
struct PerSocketData {
/* Define your user data */
int something;
};
/* Keep in mind that uWS::SSLApp({options}) is the same as uWS::App() when compiled without SSL support.
* You may swap to using uWS:App() if you don't need SSL */
uWS::SSLApp({
/* There are example certificates in uWebSockets.js repo */
.key_file_name = "misc/key.pem",
.cert_file_name = "misc/cert.pem",
.passphrase = "1234"
}).ws<PerSocketData>("/*", {
/* Settings */
.compression = uWS::SHARED_COMPRESSOR,
.maxPayloadLength = 16 * 1024,
.idleTimeout = 10,
.maxBackpressure = 1 * 1024 * 1024,
/* Handlers */
.upgrade = [](auto *res, auto *req, auto *context) {
/* HttpRequest (req) is only valid in this very callback, so we must COPY the headers
* we need later on while upgrading to WebSocket. You must not access req after first return.
* Here we create a heap allocated struct holding everything we will need later on. */
struct UpgradeData {
std::string secWebSocketKey;
std::string secWebSocketProtocol;
std::string secWebSocketExtensions;
struct us_socket_context_t *context;
decltype(res) httpRes;
bool aborted = false;
} *upgradeData = new UpgradeData {
std::string(req->getHeader("sec-websocket-key")),
std::string(req->getHeader("sec-websocket-protocol")),
std::string(req->getHeader("sec-websocket-extensions")),
context,
res
};
/* We have to attach an abort handler for us to be aware
* of disconnections while we perform async tasks */
res->onAborted([=]() {
/* We don't implement any kind of cancellation here,
* so simply flag us as aborted */
upgradeData->aborted = true;
std::cout << "HTTP socket was closed before we upgraded it!" << std::endl;
});
/* Simulate checking auth for 5 seconds. This looks like crap, never write
* code that utilize us_timer_t like this; they are high-cost and should
* not be created and destroyed more than rarely!
*
* Also note that the code would be a lot simpler with capturing lambdas, maybe your
* database client has such a nice interface? Either way, here we go!*/
struct us_loop_t *loop = (struct us_loop_t *) uWS::Loop::get();
struct us_timer_t *delayTimer = us_create_timer(loop, 0, sizeof(UpgradeData *));
memcpy(us_timer_ext(delayTimer), &upgradeData, sizeof(UpgradeData *));
us_timer_set(delayTimer, [](struct us_timer_t *t) {
/* We wrote the upgradeData pointer to the timer's extension */
UpgradeData *upgradeData;
memcpy(&upgradeData, us_timer_ext(t), sizeof(UpgradeData *));
/* Were'nt we aborted before our async task finished? Okay, upgrade then! */
if (!upgradeData->aborted) {
std::cout << "Async task done, upgrading to WebSocket now!" << std::endl;
/* If you don't want to upgrade you can instead respond with custom HTTP here,
* such as res->writeStatus(...)->writeHeader(...)->end(...); or similar.*/
/* This call will immediately emit .open event */
upgradeData->httpRes->template upgrade<PerSocketData>({
/* We initialize PerSocketData struct here */
.something = 13
}, upgradeData->secWebSocketKey,
upgradeData->secWebSocketProtocol,
upgradeData->secWebSocketExtensions,
upgradeData->context);
} else {
std::cout << "Async task done, but the HTTP socket was closed. Skipping upgrade to WebSocket!" << std::endl;
}
delete upgradeData;
us_timer_close(t);
}, 5000, 0);
},
.open = [](auto *ws) {
/* Open event here, you may access ws->getUserData() which points to a PerSocketData struct.
* Here we simply validate that indeed, something == 13 as set in upgrade handler. */
std::cout << "Something is: " << static_cast<PerSocketData *>(ws->getUserData())->something << std::endl;
},
.message = [](auto *ws, std::string_view message, uWS::OpCode opCode) {
/* We simply echo whatever data we get */
ws->send(message, opCode);
},
.drain = [](auto */*ws*/) {
/* Check ws->getBufferedAmount() here */
},
.ping = [](auto */*ws*/, std::string_view) {
/* You don't need to handle this one, we automatically respond to pings as per standard */
},
.pong = [](auto */*ws*/, std::string_view) {
/* You don't need to handle this one either */
},
.close = [](auto */*ws*/, int /*code*/, std::string_view /*message*/) {
/* You may access ws->getUserData() here, but sending or
* doing any kind of I/O with the socket is not valid. */
}
}).listen(9001, [](auto *listen_socket) {
if (listen_socket) {
std::cout << "Listening on port " << 9001 << std::endl;
}
}).run();
}
|
