puma/puma
Puma
Puma is a concurrent HTTP server for Ruby applications that implements the Rack interface. It operates as a clustered web server, using a combination of worker processes and threads to handle multiple simultaneous web connections via TCP ports or UNIX domain sockets.
The server features a master-worker process model that utilizes multiple CPU cores and employs copy-on-write preloading to reduce memory usage. It supports zero-downtime restarts through socket-handover capabilities, allowing application updates without dropping pending network requests.
The project includes a token-authenticated control interface for production administration, dynamic thread pool scaling to manage request volume, and a plugin architecture for exporting server metrics to external monitoring tools. It also provides built-in support for SSL/TLS connection security and server lifecycle hooks for executing custom logic during boot and shutdown.
Features
- Master-Worker Process Models - Implements a clustered master-worker process model to utilize multiple CPU cores and isolate request handling.
- Rack Application Servers - Provides a concurrent HTTP server designed specifically to host Ruby web applications adhering to the Rack interface.
- Network Socket Bindings - Supports binding the server to either TCP ports or UNIX domain sockets for incoming network traffic.
- Thread Pools - Manages a dynamic pool of worker threads that scales based on real-time request volume to optimize resource usage.
- Multi-Threaded Request Handling - Scales web traffic by distributing network IO and request handling across multiple CPU cores using threads and processes.
- Concurrent Request Pooling - Implements parallel HTTP request processing using a capped pool of worker threads and processes to maximize throughput.
- HTTP Servers - Provides a concurrent HTTP server engine designed to handle and route web traffic using a combination of processes and threads.
- Application Servers - Functions as a standard-compliant application server that interfaces between Ruby web frameworks and the network via Rack.
- Pre-Forking Servers - Operates as a pre-forking server that utilizes a master-worker process model to handle concurrent HTTP requests.
- Web Server Hosting - Serves as a high-performance infrastructure server for hosting Ruby web applications using the Rack protocol.
- Restart Automation - Enables server restarts without dropping pending requests through a combination of socket handover and process management.
- Zero-Downtime Upgrades - Implements zero-downtime upgrades by handing over sockets to new processes without interrupting active network connections.
- Zero-Downtime Socket Handovers - Supports zero-downtime restarts by transferring active network sockets from an old process to a new one.
- Copy-on-Write Memory Optimizations - Reduces total memory footprint by preloading application code into the master process before forking workers.
- Process Preloaders - Optimizes memory by loading application code into a master process before forking workers via copy-on-write preloading.
- Dynamic Scaling - Manages a thread pool that automatically scales between minimum and maximum limits based on traffic volume.
- TLS/SSL Configurations - Provides built-in support for SSL/TLS encrypted traffic with customizable cipher suites and certificates.
- Administrative Control Interfaces - Ships a token-authenticated control server and CLI for production administration and status querying.
- Web Servers - Modern, concurrent web server for Ruby.
