Implement SSEClient

Author: yhirose

README-sse.md

@@ -0,0 +1,182 @@
+# SSEClient - Server-Sent Events Client
+
+A simple, EventSource-like SSE client for C++11.
+
+## Features
+
+-**Auto-reconnect**: Automatically reconnects on connection loss
+-**Last-Event-ID**: Sends last received ID on reconnect for resumption
+-**retry field**: Respects server's reconnect interval
+-**Event types**: Supports custom event types via `on_event()`
+-**Async support**: Run in background thread with `start_async()`
+-**C++11 compatible**: No C++14/17/20 features required
+
+## Quick Start
+
+```cpp
+httplib::Client cli("http://localhost:8080");
+httplib::sse::SSEClient sse(cli, "/events");
+
+sse.on_message([](const httplib::sse::SSEMessage &msg){
+ std::cout << "Event: " << msg.event << std::endl;
+ std::cout << "Data: " << msg.data << std::endl;
+});
+
+sse.start(); // Blocking, with auto-reconnect
+```
+
+## API Reference
+
+### SSEMessage
+
+```cpp
+struct SSEMessage{
+ std::string event; // Event type (default: "message")
+ std::string data; // Event payload
+ std::string id; // Event ID
+};
+```
+
+### SSEClient
+
+#### Constructor
+
+```cpp
+// Basic
+SSEClient(Client &client, const std::string &path);
+
+// With custom headers
+SSEClient(Client &client, const std::string &path, const Headers &headers);
+```
+
+#### Event Handlers
+
+```cpp
+// Called for all events (or events without a specific handler)
+sse.on_message([](const SSEMessage &msg){});
+
+// Called for specific event types
+sse.on_event("update", [](const SSEMessage &msg){});
+sse.on_event("delete", [](const SSEMessage &msg){});
+
+// Called when connection is established
+sse.on_open([](){});
+
+// Called on connection errors
+sse.on_error([](httplib::Error err){});
+```
+
+#### Configuration
+
+```cpp
+// Set reconnect interval (default: 3000ms)
+sse.set_reconnect_interval(5000);
+
+// Set max reconnect attempts (default: 0 = unlimited)
+sse.set_max_reconnect_attempts(10);
+```
+
+#### Control
+
+```cpp
+// Blocking start with auto-reconnect
+sse.start();
+
+// Non-blocking start (runs in background thread)
+sse.start_async();
+
+// Stop the client (thread-safe)
+sse.stop();
+```
+
+#### State
+
+```cpp
+bool connected = sse.is_connected();
+const std::string &id = sse.last_event_id();
+```
+
+## Examples
+
+### Basic Usage
+
+```cpp
+httplib::Client cli("http://localhost:8080");
+httplib::sse::SSEClient sse(cli, "/events");
+
+sse.on_message([](const httplib::sse::SSEMessage &msg){
+ std::cout << msg.data << std::endl;
+});
+
+sse.start();
+```
+
+### With Custom Event Types
+
+```cpp
+httplib::sse::SSEClient sse(cli, "/events");
+
+sse.on_event("notification", [](const httplib::sse::SSEMessage &msg){
+ std::cout << "Notification: " << msg.data << std::endl;
+});
+
+sse.on_event("update", [](const httplib::sse::SSEMessage &msg){
+ std::cout << "Update: " << msg.data << std::endl;
+});
+
+sse.start();
+```
+
+### Async with Stop
+
+```cpp
+httplib::sse::SSEClient sse(cli, "/events");
+
+sse.on_message([](const httplib::sse::SSEMessage &msg){
+ std::cout << msg.data << std::endl;
+});
+
+sse.start_async(); // Returns immediately
+
+// ... do other work ...
+
+sse.stop(); // Stop when done
+```
+
+### With Custom Headers (e.g., Authentication)
+
+```cpp
+httplib::Headers headers ={
+{"Authorization", "Bearer token123"}
+};
+
+httplib::sse::SSEClient sse(cli, "/events", headers);
+sse.start();
+```
+
+### Error Handling
+
+```cpp
+sse.on_error([](httplib::Error err){
+std::cerr << "Error: " << httplib::to_string(err) << std::endl;
+});
+
+sse.set_reconnect_interval(1000);
+sse.set_max_reconnect_attempts(5);
+
+sse.start();
+```
+
+## SSE Protocol
+
+The client parses SSE format according to the [W3C specification](https://html.spec.whatwg.org/multipage/server-sent-events.html):
+
+```
+event: custom-type
+id: 123
+data:{"message": "hello"}
+
+data: simple message
+
+: this is a comment (ignored)
+```

README.md

@@ -1206,8 +1206,8 @@ std::string decoded_component = httplib::decode_uri_component(encoded_component)
 
 Use `encode_uri()` for full URLs and `encode_uri_component()` for individual query parameters or path segments.
 
-Streaming API
--------------
+Stream API
+----------
 
 Process large responses without loading everything into memory.
 
@@ -1234,6 +1234,28 @@ All HTTP methods are supported: `stream::Get`, `Post`, `Put`, `Patch`, `Delete`,
 
 See [README-stream.md](README-stream.md) for more details.
 
+SSE Client
+----------
+
+```cpp
+#include <httplib.h>
+
+int main(){
+ httplib::Client cli("http://localhost:8080");
+ httplib::sse::SSEClient sse(cli, "/events");
+
+ sse.on_message([](const httplib::sse::SSEMessage &msg){
+ std::cout << "Event: " << msg.event << std::endl;
+ std::cout << "Data: " << msg.data << std::endl;
+ });
+
+ sse.start(); // Blocking, with auto-reconnect
+ return 0;
+}
+```
+
+See [README-sse.md](README-sse.md) for more details.
+
 Split httplib.h into .h and .cc
 -------------------------------
 

example/Makefile

@@ -18,7 +18,7 @@ ZLIB_SUPPORT = -DCPPHTTPLIB_ZLIB_SUPPORT -lz
 BROTLI_DIR = $(PREFIX)/opt/brotli
 BROTLI_SUPPORT = -DCPPHTTPLIB_BROTLI_SUPPORT -I$(BROTLI_DIR)/include -L$(BROTLI_DIR)/lib -lbrotlicommon -lbrotlienc -lbrotlidec
 
-all: server client hello simplecli simplesvr upload redirect ssesvr ssecli ssecli-stream benchmark one_time_request server_and_client accept_header
+all: server client hello simplecli simplesvr upload redirect ssesvr ssecli benchmark one_time_request server_and_client accept_header
 
 server : server.cc ../httplib.h Makefile
 $(CXX) -o server $(CXXFLAGS) server.cc $(OPENSSL_SUPPORT)$(ZLIB_SUPPORT)$(BROTLI_SUPPORT)
@@ -47,9 +47,6 @@ ssesvr : ssesvr.cc ../httplib.h Makefile
 ssecli : ssecli.cc ../httplib.h Makefile
 $(CXX) -o ssecli $(CXXFLAGS) ssecli.cc $(OPENSSL_SUPPORT)$(ZLIB_SUPPORT)$(BROTLI_SUPPORT)
 
-ssecli-stream : ssecli-stream.cc ../httplib.h ../httplib.h Makefile
-$(CXX) -o ssecli-stream $(CXXFLAGS) ssecli-stream.cc $(OPENSSL_SUPPORT)$(ZLIB_SUPPORT)$(BROTLI_SUPPORT)
-
 benchmark : benchmark.cc ../httplib.h Makefile
 $(CXX) -o benchmark $(CXXFLAGS) benchmark.cc $(OPENSSL_SUPPORT)$(ZLIB_SUPPORT)$(BROTLI_SUPPORT)
 
@@ -67,4 +64,4 @@ pem:
  openssl req -new -key key.pem | openssl x509 -days 3650 -req -signkey key.pem > cert.pem
 
 clean:
- rm server client hello simplecli simplesvr upload redirect ssesvr ssecli ssecli-stream benchmark one_time_request server_and_client accept_header *.pem
+ rm server client hello simplecli simplesvr upload redirect ssesvr ssecli benchmark one_time_request server_and_client accept_header *.pem

example/ssecli.cc

@@ -6,16 +6,52 @@
 //
 
 #include<httplib.h>
+
+#include<csignal>
 #include<iostream>
 
 usingnamespacestd;
 
+// Global SSEClient pointer for signal handling
+httplib::sse::SSEClient *g_sse = nullptr;
+
+voidsignal_handler(int){
+if (g_sse){g_sse->stop()}
+}
+
 intmain(void){
-httplib::Client("http://localhost:1234")
- .Get("/event1", [&](constchar *data, size_t data_length){
- std::cout << string(data, data_length);
-returntrue;
- });
+// Configuration
+const string host = "http://localhost:1234";
+const string path = "/event1";
+
+ cout << "SSE Client using httplib::sse::SSEClient\n";
+ cout << "Connecting to: " << host << path << "\n";
+ cout << "Press Ctrl+C to exit\n\n";
+
+ httplib::Client cli(host);
+ httplib::sse::SSEClient sse(cli, path);
+
+// Set up signal handler for graceful shutdown
+ g_sse = &sse;
+signal(SIGINT, signal_handler);
+
+// Event handlers
+ sse.on_open([](){cout << "[Connected]\n\n"});
+
+ sse.on_message([](const httplib::sse::SSEMessage &msg){
+ cout << "Event: " << msg.event << "\n";
+ cout << "Data: " << msg.data << "\n";
+if (!msg.id.empty()){cout << "ID: " << msg.id << "\n"}
+ cout << "\n";
+ });
+
+ sse.on_error([](httplib::Error err){
+ cerr << "[Error] " << httplib::to_string(err) << "\n";
+ });
+
+// Start with auto-reconnect (blocking)
+ sse.start();
 
+ cout << "\n[Disconnected]\n";
 return0;
 }