Orbit Framework 2.0.0
A high-performance asynchronous C++20 HTTP server framework.
Loading...
Searching...
No Matches
EventRouter.hpp
Go to the documentation of this file.
1#pragma once
6#include <orbit/http/json.hpp>
7#include <string>
8#include <unordered_map>
9#include <unordered_set>
10#include <functional>
11#include <mutex>
12#include <memory>
13#include <iostream>
14
15namespace orbit::websocket {
16
17struct EmptySession {};
18
19template <typename SessionType = EmptySession>
20class EventRouter;
21
25template <typename SessionType>
27public:
30
34 template <typename T>
35 void emit(const std::string& event, const T& data) {
36 nlohmann::json payload = {{"event", event}, {"data", data}};
37 raw_.send(payload.dump());
38 }
39
43 void join(const std::string& room);
44
48 void leave(const std::string& room);
49
53 auto to(const std::string& room);
54
59
60 const std::string& id() const { return id_; }
61
62 // Internal access
64
65private:
68 std::string id_;
70 std::unordered_set<std::string> rooms_;
71
72 friend class EventRouter<SessionType>;
73};
74
78template <typename SessionType>
80public:
81 using SocketPtr = std::shared_ptr<EventSocket<SessionType>>;
82
89 template <typename PayloadType>
90 void on(const std::string& event, std::function<void(EventSocket<SessionType>&, const PayloadType&)> handler) {
92 try {
93 PayloadType data = raw_data.get<PayloadType>();
94 handler(ws, data);
95 } catch (const std::exception& e) {
96 // Ignore or log bad payload
97 LOG_DEBUG("[EventRouter] Invalid payload for event '" << event << "': " << e.what());
98 }
99 };
100 }
101
105 void on(const std::string& event, std::function<void(EventSocket<SessionType>&)> handler) {
106 handlers_[event] = [handler](EventSocket<SessionType>& ws, const nlohmann::json&) {
107 handler(ws);
108 };
109 }
110
114 void on_connect(std::function<void(EventSocket<SessionType>&)> handler) {
115 on_connect_ = [handler = std::move(handler)](EventSocket<SessionType>& socket, const http::HttpRequest&) {
116 handler(socket);
117 };
118 }
119
127 void on_connect(std::function<void(EventSocket<SessionType>&, const http::HttpRequest&)> handler) {
128 on_connect_ = std::move(handler);
129 }
130
134 void on_disconnect(std::function<void(EventSocket<SessionType>&)> handler) {
135 on_disconnect_ = std::move(handler);
136 }
137
145 void attach(server::App& app, const std::string& path, std::vector<routing::Middleware> mws = {}) {
146 app.ws(path, std::move(mws), [this](http::websocket::WebSocketConnection& raw_ws) {
147
148 // Simple UUID generation using counter and pointer for uniqueness
149 static std::atomic<uint64_t> counter = 0;
150 std::string id = "ws_" + std::to_string(++counter) + "_" + std::to_string(reinterpret_cast<uint64_t>(&raw_ws));
151
152 auto es = std::make_shared<EventSocket<SessionType>>(raw_ws, *this, id);
153
154 {
155 std::lock_guard<std::mutex> lock(mutex_);
156 sockets_[id] = es;
157 }
158
159 if (on_connect_) {
160 static const http::HttpRequest kNoRequest{};
161 const http::HttpRequest* handshake = raw_ws.handshake_request();
162 on_connect_(*es, handshake ? *handshake : kNoRequest);
163 }
164
165 raw_ws.on_message([this, id](const std::string& msg) {
166 try {
167 auto j = nlohmann::json::parse(msg);
168 if (!j.contains("event")) return;
169
170 std::string event_name = j["event"];
171 nlohmann::json data = j.contains("data") ? j["data"] : nlohmann::json(nullptr);
172
173 auto socket = get_socket(id);
174 if (socket) {
175 auto it = handlers_.find(event_name);
176 if (it != handlers_.end()) {
177 it->second(*socket, data);
178 }
179 }
180 } catch (...) {
181 // Ignore malformed JSON
182 }
183 });
184
185 raw_ws.on_close([this, id]() {
186 auto socket = get_socket(id);
187 if (socket && on_disconnect_) on_disconnect_(*socket);
188
189 std::lock_guard<std::mutex> lock(mutex_);
190 if (socket) {
191 for (const auto& room : socket->rooms_) {
192 rooms_[room].erase(id);
193 }
194 }
195 sockets_.erase(id);
196 });
197 });
198 }
199
200 // Broadcasting helper class
203 std::string room;
204
205 template <typename T>
206 void emit(const std::string& event, const T& data) {
207 nlohmann::json payload = {{"event", event}, {"data", data}};
208 std::string msg = payload.dump();
210 }
211 };
212
213 RoomBroadcaster to(const std::string& room) {
214 return RoomBroadcaster{*this, room};
215 }
216
217 // Internal API for EventSocket
218 void join_room(const std::string& id, const std::string& room) {
219 std::lock_guard<std::mutex> lock(mutex_);
220 if (sockets_.count(id)) {
221 sockets_[id]->rooms_.insert(room);
222 rooms_[room].insert(id);
223 }
224 }
225
226 void leave_room(const std::string& id, const std::string& room) {
227 std::lock_guard<std::mutex> lock(mutex_);
228 if (sockets_.count(id)) {
229 sockets_[id]->rooms_.erase(room);
230 rooms_[room].erase(id);
231 }
232 }
233
234 void broadcast_to_room(const std::string& room, const std::string& msg) {
235 std::lock_guard<std::mutex> lock(mutex_);
236 if (rooms_.count(room)) {
237 for (const std::string& id : rooms_[room]) {
238 if (sockets_.count(id)) {
239 sockets_[id]->raw().send(msg);
240 }
241 }
242 }
243 }
244
245private:
246 SocketPtr get_socket(const std::string& id) {
247 std::lock_guard<std::mutex> lock(mutex_);
248 auto it = sockets_.find(id);
249 if (it != sockets_.end()) return it->second;
250 return nullptr;
251 }
252
253 std::mutex mutex_;
254 std::unordered_map<std::string, SocketPtr> sockets_;
255 std::unordered_map<std::string, std::unordered_set<std::string>> rooms_;
256 std::unordered_map<std::string, std::function<void(EventSocket<SessionType>&, const nlohmann::json&)>> handlers_;
257
260};
261
262template <typename SessionType>
263void EventSocket<SessionType>::join(const std::string& room) {
264 router_.join_room(id_, room);
265}
266
267template <typename SessionType>
268void EventSocket<SessionType>::leave(const std::string& room) {
269 router_.leave_room(id_, room);
270}
271
272template <typename SessionType>
273auto EventSocket<SessionType>::to(const std::string& room) {
274 return router_.to(room);
275}
276
277} // namespace websocket
#define LOG_DEBUG(msg)
Definition Logger.hpp:69
a class to store JSON values
Definition json.hpp:19401
static basic_json parse(InputType &&i, const parser_callback_t cb=nullptr, const bool allow_exceptions=true, const bool ignore_comments=false)
deserialize from a compatible input
Definition json.hpp:23317
bool contains(const typename object_t::key_type &key) const
check the existence of an element in a JSON object
Definition json.hpp:22031
Represents an active WebSocket connection.
Definition WebSocketConnection.hpp:88
void send(const std::string &message)
Sends a text message over the WebSocket connection. Safe to call from any thread.
The main application class for the Orbit Framework.
Definition App.hpp:36
A Socket.IO style event router for WebSockets with Room and Session support.
Definition EventRouter.hpp:79
std::unordered_map< std::string, SocketPtr > sockets_
Definition EventRouter.hpp:254
void join_room(const std::string &id, const std::string &room)
Definition EventRouter.hpp:218
void broadcast_to_room(const std::string &room, const std::string &msg)
Definition EventRouter.hpp:234
void on_disconnect(std::function< void(EventSocket< SessionType > &)> handler)
Registers a disconnection handler.
Definition EventRouter.hpp:134
std::shared_ptr< EventSocket< SessionType > > SocketPtr
Definition EventRouter.hpp:81
void attach(server::App &app, const std::string &path, std::vector< routing::Middleware > mws={})
Attaches this EventRouter to the Orbit App at a specific path.
Definition EventRouter.hpp:145
std::unordered_map< std::string, std::function< void(EventSocket< SessionType > &, const nlohmann::json &)> > handlers_
Definition EventRouter.hpp:256
void on(const std::string &event, std::function< void(EventSocket< SessionType > &, const PayloadType &)> handler)
Definition EventRouter.hpp:90
void on(const std::string &event, std::function< void(EventSocket< SessionType > &)> handler)
Registers an untyped event handler (no data expected).
Definition EventRouter.hpp:105
SocketPtr get_socket(const std::string &id)
Definition EventRouter.hpp:246
std::function< void(EventSocket< SessionType > &, const http::HttpRequest &)> on_connect_
Definition EventRouter.hpp:258
std::function< void(EventSocket< SessionType > &)> on_disconnect_
Definition EventRouter.hpp:259
void leave_room(const std::string &id, const std::string &room)
Definition EventRouter.hpp:226
std::unordered_map< std::string, std::unordered_set< std::string > > rooms_
Definition EventRouter.hpp:255
std::mutex mutex_
Definition EventRouter.hpp:253
void on_connect(std::function< void(EventSocket< SessionType > &, const http::HttpRequest &)> handler)
Registers a connection handler that also sees the handshake request, to initialise the session from a...
Definition EventRouter.hpp:127
void on_connect(std::function< void(EventSocket< SessionType > &)> handler)
Registers a connection handler.
Definition EventRouter.hpp:114
RoomBroadcaster to(const std::string &room)
Definition EventRouter.hpp:213
Represents a connected client in the EventRouter.
Definition EventRouter.hpp:26
http::websocket::WebSocketConnection & raw()
Definition EventRouter.hpp:63
std::string id_
Definition EventRouter.hpp:68
void leave(const std::string &room)
Leaves a specific room/channel.
Definition EventRouter.hpp:268
http::websocket::WebSocketConnection & raw_
Definition EventRouter.hpp:66
EventSocket(http::websocket::WebSocketConnection &raw, EventRouter< SessionType > &router, std::string id)
Definition EventRouter.hpp:28
EventRouter< SessionType > & router_
Definition EventRouter.hpp:67
const std::string & id() const
Definition EventRouter.hpp:60
SessionType session_
Definition EventRouter.hpp:69
void join(const std::string &room)
Joins a specific room/channel.
Definition EventRouter.hpp:263
SessionType & session()
The strongly-typed session state attached to this connection.
Definition EventRouter.hpp:58
auto to(const std::string &room)
Returns a broadcaster to emit messages to everyone in the room.
Definition EventRouter.hpp:273
void emit(const std::string &event, const T &data)
Emits an event with strongly-typed data back to this specific client.
Definition EventRouter.hpp:35
std::unordered_set< std::string > rooms_
Definition EventRouter.hpp:70
basic_json<> json
default specialization
Definition json.hpp:3422
Definition legacy_namespaces.hpp:27
Definition json.hpp:5363
Represents an incoming HTTP request.
Definition HttpRequest.hpp:54
Definition EventRouter.hpp:17
void emit(const std::string &event, const T &data)
Definition EventRouter.hpp:206
EventRouter & router
Definition EventRouter.hpp:202
std::string room
Definition EventRouter.hpp:203