Worker mode not working. What am I doing wrong?

[jamiecarl]

Hi all. I'm new to FrankenPHP but have my own PHP framework that I'm trying to get working with it. I have it working fine in non-worker mode and I'm finding it a lot faster than FPM or others. So now I'm trying to get it working in worker mode and not having much luck.

So what happens is, my worker script runs, starts up and bootstraps my application correctly and I can debug it up to when it executes frankenphp_handle_request($handler), but then that's it. None of my actual requests make it to the handler.

The confusing part is that everything "appears" to work because requests are being sent to my standard index.php entrypoint.

If I remove the root * / from the Caddyfile then nothing works and I get 404s.

What am I doing wrong here? I've been through the documentation a bunch of times and come up blank, but obviously I've missed a step. I'm hoping someone can shed some light on the issue for me. Thanks.

Caddy file:

{
	frankenphp {
		worker /app/public/worker.php
	}
}

localhost:80 {
	root * public/
	encode zstd br gzip
	php_server
}

Worker script:

<?php

declare(strict_types=1);

use Hazaar\Application;

if ((!($_SERVER['FRANKENPHP_WORKER'] ?? false)) || !function_exists('frankenphp_handle_request')) {
    echo 'FrankenPHP must be in worker mode to use this script.';

    exit(1);
}

// Prevent worker script termination when a client connection is interrupted
ignore_user_abort(true);

// Composer autoloading
include __DIR__.'/../vendor/autoload.php';

// Create a new application
$app = new Application(APPLICATION_ENV);
$app->bootstrap(true);

// Handler outside the loop for better performance (doing less work)
$handler = static function () use ($app) {
    $app->run();
};

$requestCount = 0;
$maxRequests = (int) ($_ENV['MAX_REQUESTS'] ?? $_SERVER['MAX_REQUESTS'] ?? 1000);

while ($requestCount < $maxRequests && frankenphp_handle_request($handler)) {
    ++$requestCount;
    gc_collect_cycles();
}

// Cleanup
$app->shutdown();

[jamiecarl]

Update. So this is interesting. If I rename the worker.php script file to index.php and update the worker config in the Caddyfile (see below), everything works.

???Why???

{
	frankenphp {
		worker /app/public/index.php
	}
}

localhost:80 {
	root * public/
	encode zstd br gzip
	php_server
}

This isn't mentioned in the documentation, which even has worker.php as the name of the script in the examples.

[dunglas]

By convention, the path of the worker script must be the path of your front controller. This is how FrankenPHP knows that this request must be handled by the worker script and not the traditional way.

[jamiecarl]

Thanks. Makes sense. It's just not really clear from the documentation that this is the way it works. The examples, for example, say this to start a worker using Docker:

docker run \
    -e FRANKENPHP_CONFIG="worker /app/path/to/your/worker/script.php" \
    -v $PWD:/app \
    -p 80:80 -p 443:443 -p 443:443/udp \
    dunglas/frankenphp

But nowhere does it state that /app/path/to/your/worker/script.php needs to be public/index.php. Which my understanding of the default Caddyfile is that it uses php_server, which only has index.php defined in the try_files directive. So I think that stating that the worker script is /app/path/to/your/worker/script.php is a bit misleading seeing as it can really only be public/index.php.

But again, I'm new, so let me know if I'm not totally understanding this.

[dunglas]

Indeed, we need to clarify the documentation.

[jamiecarl]

Indeed, we need to clarify the documentation.

Cool cool. On the plus side, once I figured this out, I was able to tweak a few things in my framework (Hazaar MVC) and it runs beautifully in worker mode now.

Way faster too. Some quick load time stats on my test page:

PHP-FPM: ~20ms
FrankenPHP: ~8ms
FrankenPHP Worker Mode: ~2ms

I'm pretty freakin' impressed. :)

[zainsyedz]

Wait. so the working directory that we typically use in our org is /var/www/html for the root of the application.

I've just added a few folders here and there to compartmentalize the worker.php file (which isn't in the root of the application but inside the bin/frankenworker/

So, this won't work? I just want to make the code such that it can run traditionally with php-fpm and with our internal framework (which has a different implementation of the index.php)

I just broke my head for hours till I ran into this discussion.

So in my case I will need to change the root of the application to /app ?

Can't go with /var/www/html?

[withinboredom]

basically, something like this:

{
	frankenphp {
		worker my_worker /app/public/worker.php
	}
}

localhost:80 {
	root * public/
	encode zstd br gzip
	php_server via my_worker
}

or something. I haven't fleshed it out completely yet, but that's the general idea. Basically, it just routes all requests to that route/server to the specified worker.

[withinboredom]

There's some refactoring going on in that area, so I'm waiting for it to be done (I haven't checked on it in a bit, TBH).

[henderkes]

@AlliBalliBaba and I had a similar brainstorm around simplifying (and optimising) workers a bit. He came up with a php_worker directive (replacing php/php_server), or a match directive in the worker, I thought maybe our existing php/php_server directives could use a match directive.

Similar to how the root matcher in caddy works.

php {
    root /path/to/public
    match * worker index.php 4
}

[AlliBalliBaba]

Yeah still not sure what the best syntax would be, here are some ideas:

php_worker worker.php

php_server worker worker.php

php_server {
  match * worker worker.php
}

php_server {
  index worker worker.php
}

php_server {
  index_worker worker.php
}

php_server {
  entrypoint worker.php
}

[zainsyedz]

``From what I've understood, there should ideally be only one worker (not count, but one worker, that is the primary router) per application per domain.

If that's the case, I think it should be a straightforward syntax where you mention where all php files should be directed too.

For now I've just written one simple rewrite rule for all php files.
There is no nuance here, the request_uri with path remained intact too, so no faffing about there either.

I think php_server via worker_name should be the most straight forward.

Unless you want to have separate workers (example, for api and for dash) for different subdirectories, then we can have a regex pattern option too.

php_server {
  match * worker_name
}

In that case this makes most sense to me, but rather than mention the actual worker file name, I think just the worker name with match *