yuesong-feng/30dayMakeCppServer
30dayMakeCppServer
This project is a C++ TCP server framework and educational socket programming guide. It provides a high-performance network library focused on event-driven architecture, implementing a reactor pattern to handle thousands of simultaneous client connections.
The framework is distinguished by its multi-threaded event loop, which utilizes a main-sub reactor coordination model to distribute network events across a worker thread pool. It includes an abstraction layer for non-blocking socket I/O and event multiplexing via the epoll system call, decoupling network transport from application business logic through callback functions.
The project covers low-level socket programming, including connection lifecycle management and bidirectional data exchange. It incorporates concurrency primitives for task scheduling and load balancing, non-blocking I/O buffering, and automatic memory release using smart pointers.
Development tools are included for automated building, code formatting, and static analysis to maintain source code quality.
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.
