145 lines
2.7 KiB
Markdown
145 lines
2.7 KiB
Markdown
# Sockeye
|
|
|
|
An easy-to-use, fast socket C++ library! Uses epoll on Linux, kqueue on BSD/macOS.
|
|
|
|
## API Reference
|
|
|
|
### sockeye::Socket
|
|
|
|
Main server class for handling TCP connections.
|
|
|
|
#### Constructor
|
|
```cpp
|
|
explicit Socket(uint16_t port = 8080)
|
|
```
|
|
|
|
#### Methods
|
|
|
|
**`bool start()`**
|
|
Initialize the server socket and event system. Returns `true` on success.
|
|
|
|
**`void run()`**
|
|
Start the event loop. Blocks until `stop()` is called.
|
|
|
|
**`void stop()`**
|
|
Stop the server and exit the event loop.
|
|
|
|
**`void on_connection(ConnectionHandler handler)`**
|
|
Set callback for new client connections.
|
|
|
|
**`void on_data(DataHandler handler)`**
|
|
Set callback for incoming data from clients.
|
|
|
|
**`void on_disconnect(DisconnectHandler handler)`**
|
|
Set callback for client disconnections.
|
|
|
|
#### Handler Types
|
|
|
|
```cpp
|
|
using ConnectionHandler = std::function<void(int client_fd)>;
|
|
using DataHandler = std::function<void(int client_fd, const char* data, size_t len)>;
|
|
using DisconnectHandler = std::function<void(int client_fd)>;
|
|
```
|
|
|
|
## Examples
|
|
|
|
### Basic Echo Server
|
|
|
|
```cpp
|
|
#include "sockeye.hpp"
|
|
#include <iostream>
|
|
#include <cstring>
|
|
|
|
int main() {
|
|
sockeye::Socket server(8080);
|
|
|
|
server.on_connection([](int client_fd) {
|
|
std::cout << "Client connected: " << client_fd << std::endl;
|
|
});
|
|
|
|
server.on_data([](int client_fd, const char* data, size_t len) {
|
|
// Echo data back to client
|
|
send(client_fd, data, len, 0);
|
|
});
|
|
|
|
server.on_disconnect([](int client_fd) {
|
|
std::cout << "Client disconnected: " << client_fd << std::endl;
|
|
});
|
|
|
|
if (!server.start()) {
|
|
std::cerr << "Failed to start server" << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
server.run();
|
|
return 0;
|
|
}
|
|
```
|
|
|
|
### HTTP-like Server
|
|
|
|
```cpp
|
|
#include "sockeye.hpp"
|
|
#include <iostream>
|
|
#include <string>
|
|
|
|
int main() {
|
|
sockeye::Socket server(8080);
|
|
|
|
server.on_data([](int client_fd, const char* data, size_t len) {
|
|
std::string request(data, len);
|
|
|
|
// Simple HTTP response
|
|
std::string response =
|
|
"HTTP/1.1 200 OK\r\n"
|
|
"Content-Length: 13\r\n"
|
|
"Connection: close\r\n\r\n"
|
|
"Hello, World!";
|
|
|
|
send(client_fd, response.c_str(), response.length(), 0);
|
|
close(client_fd);
|
|
});
|
|
|
|
if (!server.start()) {
|
|
std::cerr << "Failed to start server" << std::endl;
|
|
return 1;
|
|
}
|
|
|
|
std::cout << "Server listening on port 8080" << std::endl;
|
|
server.run();
|
|
return 0;
|
|
}
|
|
```
|
|
|
|
### Graceful Shutdown
|
|
|
|
```cpp
|
|
#include "sockeye.hpp"
|
|
#include <signal.h>
|
|
|
|
sockeye::Socket* server_ptr = nullptr;
|
|
|
|
void signal_handler(int signal) {
|
|
if (server_ptr) {
|
|
server_ptr->stop();
|
|
}
|
|
}
|
|
|
|
int main() {
|
|
sockeye::Socket server(8080);
|
|
server_ptr = &server;
|
|
|
|
signal(SIGINT, signal_handler);
|
|
signal(SIGTERM, signal_handler);
|
|
|
|
// Set up handlers...
|
|
|
|
if (!server.start()) {
|
|
return 1;
|
|
}
|
|
|
|
server.run();
|
|
return 0;
|
|
}
|
|
```
|