Packetron: High-Throughput Node.js Framework

Packetron is a lean, high-performance Node.js web framework designed for maximum throughput and efficient resource utilization. It achieves this by leveraging the Node.js cluster module for multiprocessing and utilizing bitwise flags for ultra-fast configuration and control flow.

---

🚀 Key Features

- Multiprocessing for Scalability:
Automatically uses all available CPU cores via the Node.js cluster module to distribute the load across multiple processes. This design significantly increases throughput and application availability under high load.

- Minimal Overhead (Bitwise Flags):
Configuration and runtime control mechanisms rely on bitwise flags (e.g., in PacketronFileRouterFlags and PacketronHandlerFlags) for lightning-fast, $O(1)$ complexity checks. This eliminates the performance cost of inspecting complex configuration objects or parsing booleans.

- Pluggable Architecture:
Features a priority-based plugin system (PacketronPluginManager with PacketronPluginPriority) for clean, flexible, and organized logic execution.

- Fault Tolerance:
The master process monitors and automatically restarts worker processes that crash, ensuring continuous operation.

- Simple Routing:
Provides clear methods for handling HTTP routes (handle) and serving static files from directories or individual paths (serve, serveFile).

---

⚙️ Core Architecture Philosophy

Packetron is built around two core principles to overcome common Node.js scaling challenges:

$3

Node.js is single-threaded by nature, which limits it to a single CPU core by default. Packetron uses the cluster module to fork multiple worker processes, allowing your application to fully utilize multi-core servers and scale throughput almost linearly with the number of cores. The master process handles the spawning, monitoring, and request distribution (Round Robin scheduling) to the worker processes.

$3

Instead of checking multiple boolean properties or parsing large configuration objects, Packetron uses bitwise flags to encode multiple options into a single integer. This allows for extremely rapid configuration checks using the bitwise AND operator (&), keeping the request execution path as fast as possible.

---

🧑‍💻 Usage Example

A brief example demonstrating initialization and routing:

``js
const path = require('path');
const { Packetron, PacketronRequestMethod } = require('./Packetron');

const server = new Packetron
({
port: 3000,
maxThreads: 4 // Use 4 worker processes to utilize cores
});

// Define a simple API route
server.handle
({
method: PacketronRequestMethod.GET,
routePath: "api/status",
handler: (request, response) =>
{
response.end(JSON.stringify({ status: "ok" }));
}
});

// Serve static files from a 'public' directory at the '/static' path
server.serve
({
directory: path.join(__dirname, 'public'),
pathPrefix: 'static'
});

server.start();
``