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:

1. Full CPU Utilization (Multiprocessing)

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.

2. Performance by Design (Bitwise Flags)

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:

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();