Extensions per PHP project (project-scoped PHP extensions)

[asgrim]

Originally here: ThePHPF/pie-design#5

@Girgias suggested:

As discussed with @asgrim at PHP UK 2024.

The idea would be to install the shared object resulting from the compilation of the extension into a folder within the PHP project. This would be similar to the /vendor/ folder composer creates and uses for dependencies.

The motivation for this is to allow different version of an extension to be installed for different projects, as those might not all be compatible with newer versions of a given extension.

What is probably needed is a generated INI file that is passed to PHP to load the .so at startup.

and my reply:

I'm a big fan of this idea; however, thinking a bit more this, I think the unknown for me is how we can scope loading the shared object depending on the project. In something like a Dockerfile, there's less of an issue (since you'd usually scope your Dockerfile to an individual project and its specific requirements), but that's a small subset of applications, I'd guess.

I think off my head it is possible for PHP modules to be loaded per project (e.g. have a .user.ini) but this doesn't always work (I think in FPM mode, for example).

The other thing to consider with this, is even if we were to scope it per project, would there be an effect on performance; since extensions can take advantage of MINIT/MSHUTDOWN to avoid doing loading/unloading of things on every request, or having cross-request persistence and so on; it would essentially make every single request sequence MINIT,RINIT,RSHUTDOWN,MSHUTDOWN, which doesn't feel very efficient.

[asgrim]

Have been investigating this recently, but coming up to somewhat of a road blocker. At least on Linux, PHP currently uses dlopen(3) to pull in the .so. I tried using dlmopen but I haven't been able to figure out how to get this to work in RTLD_GLOBAL mode (which is needed, I believe, so symbols can be accessed across the board). That's the first hurdle; then there's two more I can see: namespacing/scoping each extension module entry once its loaded (fairly straightforward, this is mostly working now in my branch); the namespacing/scoping each extensions functions (and likely classes too, but we'll come to that...). Once we've figured out mechanisms to get that working; there must be some way of selecting the scope to use: do we use some syntax (like maybe declare(extension_scope=a);) or do we automatically figure this out based on the location of a composer.json / root? There's a lot to think about with this, and whilst this is theoretically possible, I'm really not sure it's worth the time investment unless there is big demand for it.

Alternative (already possible) ways of achieving this would typically be with Docker (you'd only run one project in a Docker container anyway), so everything is already "scoped" as such. I'm wondering in reality, how much people might run into this in the real world, and whether it is really worth exploring any more.