Simple Fork Laravel Package

Technical Evaluation

Architecture Fit

• Laravel Compatibility: The package is PHP-centric and integrates seamlessly with Laravel’s ecosystem, particularly for background jobs, batch processing, and CPU-bound tasks. It avoids Laravel’s queue system (e.g., Redis/Database queues) for parallelizable workloads, offering a native PHP multi-process alternative.
• Process Isolation: Ideal for stateless, CPU-intensive tasks (e.g., image/video processing, data transformations) where process isolation is preferred over threading (PHP’s lack of native threads).
• IPC Flexibility: Supports shared memory, Redis, SysV queues, and file locks, making it adaptable to existing Laravel infrastructure (e.g., Redis for caching/queues).
• Pooling Models: Aligns with Laravel’s job batching needs via FixedPool, ParallelPool, and SinglePool, enabling dynamic concurrency control.

Integration Feasibility

• Low Friction: Requires only pcntl (mandatory) and optional extensions (sysv*, redis). Laravel’s php.ini can be pre-configured for pcntl in worker environments.
• Job Wrapper: Can be wrapped as a Laravel service provider to abstract process management (e.g., SimpleForkServiceProvider with config for pool sizes, IPC methods).
• Queue Hybrid: Can coexist with Laravel queues (e.g., route non-critical jobs to SimpleFork pools while keeping critical jobs in Redis/SQS).
• Artisan Commands: Easy to expose CLI tools for managing pools (e.g., php artisan fork:reload to trigger FixedPool::reload()).

Technical Risk

• Stability: Last release in 2017 raises concerns about unpatched vulnerabilities or PHP 8+ compatibility. Mitigation:
  • Audit core methods (e.g., pcntl_signal_dispatch, fork()) for PHP 8.x.
  • Add CI checks (e.g., GitHub Actions for PHP 8.0–8.2).
  • Wrap in a service layer to isolate failures.
• Signal Handling: Custom signal logic (e.g., SIGTERM) may conflict with Laravel’s process managers (e.g., supervisor). Mitigation:
  • Document signal handler precedence (master vs. child processes).
  • Provide a fallback mechanism (e.g., graceful shutdown hooks).
• IPC Overhead: Shared memory/SysV queues may introduce latency for high-frequency IPC. Mitigation:
  • Benchmark against Redis queues for Laravel’s use case.
  • Default to Redis for cross-process communication.
• Debugging Complexity: Multi-process debugging is harder than single-threaded. Mitigation:
  • Log process IDs (getmypid()) and statuses (isStarted(), isStopped()).
  • Integrate with Laravel’s logging (e.g., monolog handlers per process).

Key Questions

1. PHP Version Support: Does the package work on PHP 8.0+? If not, what’s the effort to backport?
2. Laravel Integration Depth:
   • Can it replace Illuminate\Queue\Worker for specific job types?
   • How to handle job retries/failures (e.g., shouldRequeue()) in a process context?
3. Resource Limits:
   • How does it handle ulimit (e.g., max processes per user) in shared hosting?
   • Memory leaks in long-running pools?
4. Monitoring:
   • Can process metrics (CPU, memory) be exposed to Laravel’s monitoring (e.g., Prometheus)?
   • How to correlate logs from master/child processes?
5. Alternatives:
   • For I/O-bound tasks, is ReactPHP or Swoole a better fit?
   • For distributed scaling, would Kubernetes + PHP workers be worth the complexity?

Integration Approach

Stack Fit

• Laravel Core: Integrates with:
  • Artisan: CLI commands for pool management (e.g., fork:start, fork:stop).
  • Service Container: Register SimpleFork pools as singletons with configurable defaults.
  • Events: Emit events for pool lifecycle (e.g., ProcessPoolStarted, ProcessFailed).
• Queue System:
  • Hybrid Model: Route jobs to SimpleFork pools for parallelizable tasks, keep critical jobs in Redis/SQS.
  • Job Adapter: Create a SimpleForkJob class extending Laravel’s Job interface.
• IPC Strategy:
  • Default: Use Redis for cross-process communication (leverages Laravel’s existing Redis config).
  • Fallback: SysV shared memory for low-latency local IPC (if Redis is overkill).
• Process Isolation:
  • Dedicated PHP Binaries: Run pools in separate PHP processes (e.g., php artisan fork:worker) to avoid conflicts with Laravel’s FPM.
  • Environment Separation: Use .env variables to configure pool sizes, IPC methods, and timeouts.

Migration Path

1. Phase 1: Proof of Concept
   • Replace a synchronous batch job (e.g., CSV import) with a FixedPool.
   • Example:

     // app/Providers/SimpleForkServiceProvider.php
     public function register()
     {
         $this->app->singleton('csv.import.pool', function () {
             return new \Jenner\SimpleFork\FixedPool(4);
         });
     }
     

   • Test with pcntl enabled in php.ini:

     extension=pcntl
     

2. Phase 2: Job Integration
   • Create a SimpleForkJob class:

     class ParallelImageResizeJob implements \Jenner\SimpleFork\Runnable {
         public function run() {
             // Resize logic here
         }
     }
     

   • Dispatch via Artisan:

     php artisan fork:execute ParallelImageResizeJob --pool-size=8
     

3. Phase 3: Queue Hybrid
   • Extend Laravel’s queue system:

     // app/Console/Kernel.php
     protected function schedule(Schedule $schedule) {
         $schedule->job(new ParallelImageResizeJob)
                  ->onSimpleForkPool('image.resize', 4);
     }
     

   • Add a SimpleForkQueue class to route jobs to pools.
4. Phase 4: Monitoring
   • Log process metrics to Laravel’s logging system.
   • Expose pool status via HTTP endpoint (e.g., /api/process-pools).

Compatibility

• PHP Extensions:
  • Mandatory: pcntl (enable in php.ini for worker environments).
  • Optional: sysv*, redis (fallback to Redis for cross-process comms).
• Laravel Versions:
  • Tested on Laravel 8+ (PHP 8.0+ compatibility may require patches).
  • Avoid Laravel’s built-in queue workers for these jobs (conflict risk).
• Operating Systems:
  • Linux/Unix (required for pcntl and SysV IPC).
  • Windows: Not supported (use Docker containers with Linux for cross-platform deployments).

Sequencing

1. Pre-requisites:
   • Enable pcntl in PHP and worker environments.
   • Configure Redis/SysV IPC methods in .env.
2. Core Integration:
   • Register SimpleFork as a Laravel service provider.
   • Implement a SimpleForkJob interface for reusable workers.
3. Queue Hybrid:
   • Extend Laravel’s queue system to route jobs to pools.
   • Add Artisan commands for pool management.
4. Monitoring:
   • Instrument pools with Laravel’s logging/monitoring.
   • Expose metrics via API or third-party tools (e.g., Prometheus).
5. Rollout:
   • Start with non-critical batch jobs (e.g., reports, backups).
   • Gradually migrate CPU-bound tasks from queues to pools.

Operational Impact

Maintenance

• Dependency Risk:
  • Low: MIT license, no external dependencies beyond PHP extensions.
  • Mitigation: Fork the repo to apply PHP 8.x patches if needed.
• Upgrade Path:
  • Monitor for pcntl or IPC extension updates.
  • Test with new PHP/Laravel versions in staging.
• Documentation:
  • Add internal docs for:
    • Pool configuration (e.g., FixedPool sizes).
    • IPC method tradeoffs (Redis vs. SysV).
    • Signal handling edge cases.

Support

• Debugging:
  • Process Isolation: Log getmypid() and process statuses (isStarted()) for debugging.
  • Log Correlation: Use Laravel’s monolog with process IDs in log context.
  • Tooling: Integrate with htop/ps for monitoring worker processes.
• Failure Modes:
  • Zombie Processes: Handled automatically by the package, but