Major refactoring

examples/http2_client.cpp

@@ -27,13 +27,13 @@ std::mutex g_mutex;
 std::condition_variable g_cv;
 
 /// Perform HTTP/2 requests demonstrating various features
-coro::task<void> run_client(io::io_context& io_ctx, const std::string& base_url) {
+coro::task<void> run_client(const std::string& base_url) {
     // Create HTTP/2 client with custom config
     h2_client_config config;
     config.user_agent = "elio-http2-client-example/1.0";
     config.max_concurrent_streams = 100;
-    
-    h2_client client(io_ctx, config);
+
+    h2_client client(config);
 
     ELIO_LOG_INFO("=== HTTP/2 Client Example ===");
     ELIO_LOG_INFO("Base URL: {}", base_url);
@@ -89,11 +89,11 @@ coro::task<void> run_client(io::io_context& io_ctx, const std::string& base_url)
 }
 
 /// Simple one-off HTTP/2 request demonstration
-coro::task<void> simple_request(io::io_context& io_ctx, const std::string& url) {
+coro::task<void> simple_request(const std::string& url) {
     ELIO_LOG_INFO("Fetching via HTTP/2: {}", url);
-    
+
     // Use convenience function for one-off requests
-    auto result = co_await h2_get(io_ctx, url);
+    auto result = co_await h2_get(url);
 
     if (result) {
         auto& resp = *result;
@@ -155,10 +155,10 @@ int main(int argc, char* argv[]) {
 
     // Run appropriate mode
     if (full_demo) {
-        auto task = run_client(io::default_io_context(), url);
+        auto task = run_client(url);
         sched.spawn(task.release());
     } else {
-        auto task = simple_request(io::default_io_context(), url);
+        auto task = simple_request(url);
         sched.spawn(task.release());
     }
 

examples/http_client.cpp

@@ -25,14 +25,14 @@ std::mutex g_mutex;
 std::condition_variable g_cv;
 
 /// Perform multiple HTTP requests demonstrating various features
-coro::task<void> run_client(io::io_context& io_ctx, const std::string& base_url) {
+coro::task<void> run_client(const std::string& base_url) {
     // Create client with custom config
     client_config config;
     config.user_agent = "elio-http-client-example/1.0";
     config.follow_redirects = true;
     config.max_redirects = 5;
-    
-    client c(io_ctx, config);
+
+    client c(config);
 
     ELIO_LOG_INFO("=== HTTP Client Example ===");
     ELIO_LOG_INFO("Base URL: {}", base_url);
@@ -184,11 +184,11 @@ coro::task<void> run_client(io::io_context& io_ctx, const std::string& base_url)
 }
 
 /// Simple one-off request demonstration
-coro::task<void> simple_request(io::io_context& io_ctx, const std::string& url) {
+coro::task<void> simple_request(const std::string& url) {
     ELIO_LOG_INFO("Fetching: {}", url);
-    
+
     // Use convenience function for one-off requests
-    auto result = co_await http::get(io_ctx, url);
+    auto result = co_await http::get(url);
 
     if (result) {
         auto& resp = *result;
@@ -240,10 +240,10 @@ int main(int argc, char* argv[]) {
 
     // Run appropriate mode
     if (full_demo) {
-        auto task = run_client(io::default_io_context(), url);
+        auto task = run_client(url);
         sched.spawn(task.release());
     } else {
-        auto task = simple_request(io::default_io_context(), url);
+        auto task = simple_request(url);
         sched.spawn(task.release());
     }
 

examples/http_server.cpp

@@ -268,30 +268,26 @@ int main(int argc, char* argv[]) {
     if (use_https) {
         try {
             auto tls_ctx = tls::tls_context::make_server(cert_file, key_file);
-            
+
             auto server_task = srv.listen_tls(
-                bind_addr, 
-                io::default_io_context(), 
-                sched,
+                bind_addr,
                 tls_ctx,
                 opts
             );
             sched.spawn(server_task.release());
-            
+
             ELIO_LOG_INFO("HTTPS server started on {}", bind_addr.to_string());
         } catch (const std::exception& e) {
             ELIO_LOG_ERROR("Failed to start HTTPS server: {}", e.what());
             return 1;
         }
     } else {
         auto server_task = srv.listen(
-            bind_addr, 
-            io::default_io_context(), 
-            sched,
+            bind_addr,
             opts
         );
         sched.spawn(server_task.release());
-        
+
         ELIO_LOG_INFO("HTTP server started on {}", bind_addr.to_string());
     }
 

examples/rpc_server_example.cpp

@@ -188,10 +188,8 @@ task<void> signal_handler_task() {
 }
 
 task<void> server_main(uint16_t port, [[maybe_unused]] scheduler& sched) {
-    auto& ctx = io::default_io_context();
-
     // Bind TCP listener
-    auto listener_result = tcp_listener::bind(ipv4_address(port), ctx);
+    auto listener_result = tcp_listener::bind(ipv4_address(port));
     if (!listener_result) {
         ELIO_LOG_ERROR("Failed to bind to port {}: {}", port, strerror(errno));
         co_return;

examples/sse_client.cpp

@@ -31,18 +31,18 @@ std::mutex g_mutex;
 std::condition_variable g_cv;
 
 /// Listen to SSE events
-coro::task<void> listen_events(io::io_context& io_ctx, const std::string& url) {
+coro::task<void> listen_events(const std::string& url) {
     ELIO_LOG_INFO("=== SSE Client Demo ===");
     ELIO_LOG_INFO("Connecting to: {}", url);
-    
+
     // Configure client
     client_config config;
     config.user_agent = "elio-sse-demo/1.0";
     config.auto_reconnect = true;
     config.default_retry_ms = 3000;
     config.verify_certificate = false;  // Allow self-signed certs for testing
-    
-    sse_client client(io_ctx, config);
+
+    sse_client client(config);
 
     // Connect
     bool connected = co_await client.connect(url);
@@ -105,10 +105,10 @@ coro::task<void> listen_events(io::io_context& io_ctx, const std::string& url) {
 }
 
 /// Simple connection test
-coro::task<void> simple_test(io::io_context& io_ctx, const std::string& url) {
+coro::task<void> simple_test(const std::string& url) {
     ELIO_LOG_INFO("Simple SSE test: connecting to {}", url);
-    
-    auto client_opt = co_await sse_connect(io_ctx, url);
+
+    auto client_opt = co_await sse_connect(url);
     if (!client_opt) {
         ELIO_LOG_ERROR("Failed to connect");
         {
@@ -145,15 +145,15 @@ coro::task<void> simple_test(io::io_context& io_ctx, const std::string& url) {
 }
 
 /// Test reconnection behavior
-coro::task<void> reconnect_test(io::io_context& io_ctx, const std::string& url) {
+coro::task<void> reconnect_test(const std::string& url) {
     ELIO_LOG_INFO("Reconnection test: connecting to {}", url);
-    
+
     client_config config;
     config.auto_reconnect = true;
     config.default_retry_ms = 2000;
     config.max_reconnect_attempts = 3;
-    
-    sse_client client(io_ctx, config);
+
+    sse_client client(config);
 
     if (!co_await client.connect(url)) {
         ELIO_LOG_ERROR("Initial connection failed");
@@ -240,17 +240,17 @@ int main(int argc, char* argv[]) {
     // Run client based on mode
     switch (mode) {
         case Mode::demo: {
-            auto task = listen_events(io::default_io_context(), url);
+            auto task = listen_events(url);
             sched.spawn(task.release());
             break;
         }
         case Mode::simple: {
-            auto task = simple_test(io::default_io_context(), url);
+            auto task = simple_test(url);
             sched.spawn(task.release());
             break;
         }
         case Mode::reconnect: {
-            auto task = reconnect_test(io::default_io_context(), url);
+            auto task = reconnect_test(url);
             sched.spawn(task.release());
             break;
         }

examples/sse_server.cpp

@@ -119,9 +119,14 @@ class sse_http_server {
     explicit sse_http_server(router r, server_config config = {})
         : router_(std::move(r)), config_(config) {}
 
-    coro::task<void> listen(const net::ipv4_address& addr, io::io_context& io_ctx,
-                           runtime::scheduler& sched) {
-        auto listener_result = net::tcp_listener::bind(addr, io_ctx);
+    coro::task<void> listen(const net::ipv4_address& addr) {
+        auto* sched = runtime::scheduler::current();
+        if (!sched) {
+            ELIO_LOG_ERROR("SSE server must be started from within a scheduler context");
+            co_return;
+        }
+
+        auto listener_result = net::tcp_listener::bind(addr);
         if (!listener_result) {
             ELIO_LOG_ERROR("Failed to bind SSE server: {}", strerror(errno));
             co_return;
@@ -142,7 +147,7 @@ class sse_http_server {
             }
 
             auto handler = handle_connection(std::move(*stream_result));
-            sched.spawn(handler.release());
+            sched->spawn(handler.release());
         }
     }
 
@@ -373,11 +378,7 @@ int main(int argc, char* argv[]) {
     sched.spawn(sig_handler.release());
 
     // Start server
-    auto server_task = srv.listen(
-        net::ipv4_address(port),
-        io::default_io_context(),
-        sched
-    );
+    auto server_task = srv.listen(net::ipv4_address(port));
     sched.spawn(server_task.release());
 
     ELIO_LOG_INFO("SSE server started on port {}", port);

examples/tcp_echo_server.cpp

@@ -98,11 +98,8 @@ task<void> handle_client(tcp_stream stream, int client_id) {
 
 /// Main server loop - accepts connections and spawns handlers
 task<void> server_main(const socket_address& bind_addr, const tcp_options& opts, scheduler& sched) {
-    // Use the default io_context which is polled by scheduler workers
-    auto& ctx = io::default_io_context();
-
     // Bind TCP listener
-    auto listener_result = tcp_listener::bind(bind_addr, ctx, opts);
+    auto listener_result = tcp_listener::bind(bind_addr, opts);
     if (!listener_result) {
         ELIO_LOG_ERROR("Failed to bind to {}: {}", bind_addr.to_string(),
                       strerror(errno));

examples/uds_echo_server.cpp

@@ -88,14 +88,11 @@ task<void> handle_client(uds_stream stream, int client_id) {
 
 /// Main server loop - accepts connections and spawns handlers
 task<void> server_main(const unix_address& addr, scheduler& sched) {
-    // Use the default io_context which is polled by scheduler workers
-    auto& ctx = io::default_io_context();
-
     // Bind UDS listener
     uds_options opts;
     opts.unlink_on_bind = true;  // Remove existing socket file if any
-    
-    auto listener_result = uds_listener::bind(addr, ctx, opts);
+
+    auto listener_result = uds_listener::bind(addr, opts);
     if (!listener_result) {
         ELIO_LOG_ERROR("Failed to bind to {}: {}", addr.to_string(),
                       strerror(errno));

examples/websocket_client.cpp

@@ -73,16 +73,16 @@ coro::task<void> interactive_session(ws_client& client) {
 }
 
 /// Demonstrate various WebSocket features
-coro::task<void> demo_features(io::io_context& io_ctx, const std::string& url) {
+coro::task<void> demo_features(const std::string& url) {
     ELIO_LOG_INFO("=== WebSocket Client Demo ===");
     ELIO_LOG_INFO("Connecting to: {}", url);
-    
+
     // Configure client
     client_config config;
     config.user_agent = "elio-websocket-demo/1.0";
     config.verify_certificate = false;  // Allow self-signed certs for testing
-    
-    ws_client client(io_ctx, config);
+
+    ws_client client(config);
 
     // Connect
     bool connected = co_await client.connect(url);
@@ -176,10 +176,10 @@ coro::task<void> demo_features(io::io_context& io_ctx, const std::string& url) {
 }
 
 /// Simple echo test
-coro::task<void> echo_test(io::io_context& io_ctx, const std::string& url) {
+coro::task<void> echo_test(const std::string& url) {
     ELIO_LOG_INFO("Echo test: connecting to {}", url);
-    
-    auto client_opt = co_await ws_connect(io_ctx, url);
+
+    auto client_opt = co_await ws_connect(url);
     if (!client_opt) {
         ELIO_LOG_ERROR("Failed to connect");
         {
@@ -262,10 +262,10 @@ int main(int argc, char* argv[]) {
 
     // Run client
     if (demo_mode) {
-        auto task = demo_features(io::default_io_context(), url);
+        auto task = demo_features(url);
         sched.spawn(task.release());
     } else {
-        auto task = echo_test(io::default_io_context(), url);
+        auto task = echo_test(url);
         sched.spawn(task.release());
     }
 

examples/websocket_server.cpp

@@ -316,11 +316,7 @@ int main(int argc, char* argv[]) {
     sched.spawn(sig_handler.release());
 
     // Start server
-    auto server_task = srv.listen(
-        net::ipv4_address(port),
-        io::default_io_context(),
-        sched
-    );
+    auto server_task = srv.listen(net::ipv4_address(port));
     sched.spawn(server_task.release());
 
     ELIO_LOG_INFO("WebSocket server started on port {}", port);