yuesong-feng/30dayMakeCppServer

Features

• TCP/IP Socket Programming Guides - Serves as a comprehensive educational guide and resource for implementing TCP/IP socket programming in C++.
• Reactor Patterns - Provides a complete implementation of the reactor pattern to dispatch high-concurrency network events to handlers.
• C++ Networking Libraries - Provides a networking library specifically for C++ to implement TCP servers and data exchange.
• IO Multiplexing - Utilizes kernel-level IO multiplexing via epoll to monitor and manage thousands of concurrent connections on a single thread.
• Network Socket Bindings - Enables binding server listeners to specific network interfaces and port numbers for identification.
• Multi-Threaded Event Distribution - Implements a multi-threaded event distribution system to parallelize network event processing across CPU cores.
• Multi-Reactor Implementations - Implements a multi-reactor architecture that distributes network event processing across a worker thread pool.
• Socket Networking - Provides low-level socket management for establishing raw TCP and UDP communication endpoints.
• Non-Blocking Socket I/O - Implements asynchronous reading and writing of network sockets to prevent execution stalls during network latency.
• Epoll Wrappers - Ships a C++ abstraction layer for managing non-blocking socket I/O via the epoll system call.
• Socket Buffers - Implements dedicated socket buffers to accumulate raw data streams and decouple low-level IO from logic.
• TCP Server Frameworks - Provides a high-performance C++ TCP server framework with an event-driven architecture.
• TCP Socket Programming - Manages the complete lifecycle of TCP sockets from creation and binding to accepting connections.
• Network Event Monitoring Schedulers - Provides low-level scheduling to monitor and trigger network read and write events across multiple file descriptors.
• Event-Driven Architectures - Implements an event-driven server architecture based on the reactor pattern using epoll.
• Event-Driven Callbacks - Binds business logic callbacks to socket descriptors using an event-driven pattern for asynchronous request handling.
• Non-blocking IO Architectures - Implements non-blocking I/O architectures using multiplexing to prevent thread blocking during network tasks.
• Reactor Pattern Event Loops - Utilizes a reactor-based event loop to monitor multiple file descriptors and trigger registered callbacks.
• Event Dispatchers - Routes network events triggered by file descriptors to registered listener objects for targeted processing.
• Socket Event Loops - Implements socket event loops that monitor multiple file descriptors and trigger non-blocking callback functions.
• OS Event Polling - Implements a high-level interface for OS-native polling mechanisms like epoll to monitor network I/O readiness.
• Network Load Balancing Strategies - Employs scheduling strategies to distribute new network connections evenly across worker threads.
• Concurrent Task Execution - Supports executing asynchronous functions in a thread pool and retrieving results via futures.
• Bidirectional Socket Communication - Facilitates reading data from sockets into buffers and writing responses back to clients.
• Connection Lifecycle Managers - Includes a centralized server manager to track active client connections and manage their lifecycles.
• Buffered Message Callbacks - Executes business logic callbacks only after the server has fully received and buffered a complete message from a client.
• I/O Buffering - Ships non-blocking I/O buffers to decouple socket data transmission from application logic.
• TCP Connection Acceptance - Handles the server-side acceptance of incoming TCP connections on bound addresses.
• File Descriptor Metadata Mapping - Binds raw system file descriptors to dedicated objects to store connection metadata and track specific event interests.
• Task Schedulers - Implements task scheduling to distribute network events across multiple CPU cores via worker pools.
• Business Logic Components - Isolates business logic from network transport by transforming connection events into application states via callbacks.
• Worker Queue Management - Distributes network events across worker threads via a synchronized queue to reduce switching overhead.
• File Descriptor Mappings - Provides a mechanism to associate raw socket file descriptors with connection metadata objects.
• Resource Ownership Transfer - Utilizes C++ move semantics to transfer ownership of network resources and eliminate unnecessary memory copying.
• OS-Specific Event Notifications - Provides abstractions for monitoring socket events using system-specific interfaces like epoll and kqueue.
• Object-Oriented Socket Wrappers - Provides an object-oriented interface for socket creation, binding, and listening to abstract low-level system calls.

Star history