La gestion des extensions PHP est aussi simple que PIE

Je pense qu'il n'y a jamais eu de meilleur moment pour être un développeur PHP. Peut-être que je porte des lunettes roses, ou peut-être que je n'ai tout simplement pas connu assez de douleur historique, mais FrankenPHP a donné au langage un nouveau runtime rapide comme l'éclair, et les applications PHP peuvent maintenant être construites nativement pour les appareils Android et iOS gratuitement avec NativePHP.

Dans cet article, nous allons nous intéresser à l'outil PHP Installer for Extensions (PIE) et créer une extension PHP personnalisée.

Gestionnaires de paquets et d'extensions en PHP

Je reçois souvent des hochements de tête complices lorsque j'aborde le sujet de la musique. compositeur est abordé. Cela s'accompagne généralement de l'affirmation que "PHP a le meilleur gestionnaire de paquets". En raison des fonctionnalités robustes de Composer, je ne pense pas avoir jamais jamais que je n'ai jamais rencontré de difficultés avec lui. Je me suis dit : "Quelles sont les circonstances de l'écosystème qui nous donnent des outils comme celui-ci ?" Sans vouloir minimiser l'immense travail de Nils et de Jordi qui l'ont rendu possible, mais j'ai aussi remarqué que PHP a tendance à avoir beaucoup d'outils de facto, que moins c'est plus. Composer est notre gestionnaire de paquets de facto. Comparez cela avec, disons, Node ou Python, où les développeurs doivent avoir le doigt sur le pouls pour voir ce qui vient ensuite et ce que la communauté décide "d'être le meilleur". De nouveaux outils apparaissent pour tenter de remédier aux limites de la situation actuelle.

Which JavaScript manager is it this week?Compositeur remplacé PEAR. Mais pour les extensions C sur PHP, cela a toujours été PECL. Dans le même cycle de vie, il semble que nous ayons maintenant notre nouvelle "extension de-facto d'extension de facto" sous la forme de PIE. Avant de voir comment l'utiliser et ce qu'il peut faire, j'ai pensé qu'il valait mieux poser quelques questions brûlantes à son auteur, James Titcumb.

Du PEAR au PECL et au PIE : le point de vue de l'auteur

La relation entre PECL et PEAR est quelque peu confuse. Comment et quand PECL a-t-il vu le jour ?

PEAR - le PHP Extension and Application Repository a été fondé en 1999 en tant qu'outil et système de distribution pour le code PHP. Fonctionnellement, il fait ce que Composer fait maintenant, mais avec une approche légèrement différente. PECL en était une émanation ; un outil autonome pour se connecter aux canaux PEAR et construire des extensions. Ce système est extrêmement archaïque, et alors que PEAR a été pratiquement éclipsé par Composer, PECL a, jusqu'à récemment, été le moyen standard d'installer des extensions PHP.

Étant donné que le PECL existe depuis toujours, pourquoi le PIE doit-il être mis en place dès maintenant ?

Le projet PIE est en partie financé par la Sovereign Tech Agency, un programme du gouvernement allemand visant à promouvoir et à assurer la viabilité à long terme des technologies open source. PECL a toujours été difficile à maintenir, est bien inférieur en termes de gestion des dépendances à Composer, et nécessite une maintenance de l'infrastructure. Le nombre de personnes qui savent comment fonctionne cette infrastructure est inquiétant. Ainsi, en accord avec l'objectif de la Fondation PHP de réduire le "facteur bus" pour PECL et son infrastructure associée, PIE est né, dans le but de résoudre ces problèmes.

Mes sources confidentielles m'informent que vous travaillez pour la "Fondation PHP". Qu'est-ce que c'est et quel travail y faites-vous ?

La Fondation PHP est une organisation créée à l'origine parce qu'un groupe de personnes s'est réuni, réalisant que le nombre de personnes qui travaillaient activement sur PHP était si faible, deux, puis jusqu'à un seul à un moment donné. L'objectif est d'assurer la viabilité à long terme du langage de programmation PHP, ce qui est important quand on sait qu'une grande partie du web fonctionne sur des systèmes PHP ! L'une des missions de la fondation est d'employer des développeurs pour travailler sur PHP et son écosystème proche. à la recherche de sponsors.

Quelles sont les nouveautés attendues pour 2026 ?

Une grande partie du développement de la série PIE 1.4 est de s'assurer que PIE fonctionne mieux avec les systèmes d'installation d'extensions existants qui enveloppaient auparavant PECL ou avaient leur propre façon de faire (comme dans Docker), ainsi que de soulager les utilisateurs finaux qui ont besoin d'installer des prérequis (comme des outils de construction, des bibliothèques système, etc). Nous fournirons également, à titre expérimental, des binaires exécutables préconstruits de PIE lui-même en utilisant un outil appelé Static PHP. Beaucoup d'autres choses se profilent à l'horizon. L'objectif final est que PIE remplace complètement PECL, et nous travaillons dans ce sens.

Tutoriel : Utiliser PIE pour gérer les extensions

Ce tutoriel est donc divisé en deux parties. Tout d'abord, nous installerons PIE et l'utiliserons pour récupérer un exemple d'extension. Ensuite, nous passerons aux choses plus complexes en écrivant notre propre extension et en demandant à PIE de la compiler.

Comment va votre C ?

C'est bien cela. C. J'ai souvent parlé à des développeurs d'autres communautés linguistiques, et ils sont souvent très surpris d'apprendre pour la première fois que Rasmus Lerdorf a conçu PHP comme un langage compilé à partir du C. Alors, pour écrire une extension PHP qui sera utilisée par PIE ? Oui, ce sera en C.

Installation de PIE

PIE se présente sous la forme d'un exécutable PHAR (Un clin d'œil à Davey Shafik de l'époque pour son travail remarquable dans la mise en place de PIE en PHP). Vous pouvez télécharger le PHAR depuis iciet le mettre dans le PATH de l'exécutable de la ligne de commande, quel que soit le système d'exploitation que vous utilisez.

Une fois que vous avez défini un alias dans votre fichier RC du shell ou ajouté PIE à votre chemin d'accès, vous pouvez l'utiliser pour installer un exemple d'extension. C'est ce que nous allons faire en premier, avant de créer notre propre extension.

pie install asgrim/example_pie_extension

Composer, but slightly different!Fantastique, c'est installé. Il est temps de vérifier si cela fonctionne : créez un nouveau fichier PHP et ajoutez ce qui suit :

test.php

<?php
    example_pie_extension_test();

Sorties :

php test.php

Hello, world!

Ah, le vieux classique. Nous sommes en train de cuisiner.

Écrire notre propre extension PHP

Ceux qui connaissent le programme Laravel connaissent l'infâme dd() tristement célèbre. Il exécute à la fois var_dump()et ensuite die(). Ce code se trouve dans le noyau de Laravel, mais que se passerait-il si nous décidions de coder notre propre extension pour avoir nativement cette fonction au moment de l'exécution de PHP ? C'est exactement ce que nous allons faire !

Commencez par créer un dossier de projet. Par exemple :

mkdir native_dd
cd native_dd && touch native_dd.c

J'espère que vous avez installé vos extensions de langage C sur votre IDE !

Nous avons créé native_dd.c. Comme nous sommes maintenant au pays du C, il est temps de commencer à coder avec le moteur Zend !

#include "php.h"
#include <ext/standard/php_var.h>
#include "php_native_dd.h"

PHP_FUNCTION(native_dd)
{
   zval *value;

   ZEND_PARSE_PARAMETERS_START(1, 1)
       Z_PARAM_ZVAL(value)
   ZEND_PARSE_PARAMETERS_END();

   php_var_dump(value, 0);
  
   php_printf("\n");
   php_output_flush();

   zend_bailout();
}

ZEND_BEGIN_ARG_INFO(arginfo_native_dd_test, 0)
ZEND_END_ARG_INFO()

static const zend_function_entry native_dd_functions[] = {
   PHP_FE(native_dd, arginfo_native_dd_test)
   PHP_FE_END
};

zend_module_entry native_dd_module_entry = {
   STANDARD_MODULE_HEADER,
   "native_dd",
   native_dd_functions,
   NULL,
   NULL,
   NULL,
   NULL,
   NULL,
   "0.1.0",
   STANDARD_MODULE_PROPERTIES
};

ZEND_GET_MODULE(native_dd)

Il y a plusieurs choses à noter ici. Tout d'abord, pour coder une fonction PHP, vous devez adhérer à la structure utilisée par le moteur Zend. Vous pouvez en savoir plus sur ces exigences ici : https://www.phpinternalsbook.com/php5/build_system/building_extensions.html.

Une fois que nous avons obtenu tous les fichiers dont nous avons besoin, la structure des fichiers de votre projet devrait ressembler à ceci :

pietest/
  composer.json
  composer.lock
  config.m4
  native_dd.c
  php_native_dd.h
  test.php

Ne vous inquiétez pas s'il vous manque des fichiers à ce stade ; nous les trouverons.

En résumé, voici ce qu'il faut retenir :

• Vous devez inclure PHP en premiercar l'ordre d'inclusion en C est important

• Ce module utilise une partie de la bibliothèque standard (php_var_dump()), qui doit donc être importée : #include <ext/standard/php_var.h>

• Vous devez inclure un fichier d'en-tête pour la fonction, nous y reviendrons plus tard.

• Le nom utilisé pour la couche API de PHP en C est PHP_FUNCTION() pour la définition, ZEND_BEGIN_ARG_INFO() et ZEND_END_ARG_INFO() pour plus de détails dans les arguments. zend_function_entry <your-module-name> avec le suffixe <your-module-name>_functions[] est utilisé avec une macro, PHP_FEqui compile votre fonction en une fonction interne de Zend. Les dernières étapes sont la définition de la fonction en tant que module avec zend_module_entry et ZEND_GET_MODULE.

• php_var_dumpla même fonction sous-jacente utilisée par PHP est importée. var_dump est importée et utilisée

• L'équivalent de die() est utilisé, qui est zend_bailout()

Il est compréhensible que la plupart de ces éléments puissent sembler étrangers aux développeurs PHP comme moi. Se familiariser avec les bizarreries de Zend Engine et les définitions d'API n'est pas pour les âmes sensibles, mais la partie la plus intéressante est celle de PIE.

Le module nécessite un fichier d'en-tête et un fichier de configuration, créez donc un fichier config.m4 et un fichier php_native_dd.h fichier.

config.m4

PHP_ARG_ENABLE(native_dd, whether to enable native_dd,
[  --enable-native-dd   Enable native_dd])

if test "$PHP_NATIVE_DD" != "no"; then
    PHP_NEW_EXTENSION(native_dd, native_dd.c, $ext_shared)
fi


php_native_dd.h

#ifndef PHP_NATIVE_DD_H
#define PHP_NATIVE_DD_H

extern zend_module_entry native_dd_module_entry;
#define phpext_native_dd_ptr &native_dd_module_entry

#endif

Il y a des années, je crois me souvenir que j'ai essayé de compiler mon propre module et que j'ai échoué lamentablement avec la plateforme sur laquelle j'essayais de le construire. Je ne pense pas qu'à l'époque je savais même comment fonctionnaient des choses comme GCC et MAKEFILEs.

Alors, devinez ce que nous allons faire maintenant ? C'est exact, nous allons utiliser PIE pour lui faire faire tout le travail difficile.

La compilation d'une facilité déconcertante ...

... si tout est bien réglé.

PIE nécessite diverses bibliothèques au niveau du système d'exploitation. assurez-vous d'avoir tout ce qu'il faut.

Pour les auteurs d'extensions, vous traitez votre code C comme n'importe quelle autre dépendance - en utilisant Composer. Notre code composer.json de notre code ressemble à ceci :

{
   "name": "jimseconde/nativedd",
   "description": "A Native dd() helper for core PHP to be installed with PIE",
   "authors": [
       {
           "name": "jimseconde",
           "email": "jim.seconde@googlemail.com"
       }
   ],
   "require": {
       "php": "^8.3"
   },
   "type": "php-ext",
   "php-ext": {
       "extension-name": "native_dd"
   },
   "license": "MIT"
}

La partie importante ici est typequi indique à Composer qu'il ne s'agit pas d'une dépendance PHP, mais que php-ext le définit comme une extension. Vous devez l'accompagner de l'option php-ext qui définit l'élément extension-name. Lorsque vous exécutez PIE avec pie installle code PIE examinera le fichier composer.json et le construit à partir de là :

pie install

Built, enabled, and loaded!Créez maintenant un fichier PHP de test et utilisez-le.

<?php

$myVariable = "test string";
native_dd($myVariable);

Exécutez-le, et :

php test.php

string(11) "test string"

Fait.

Conclusion

Je dois admettre que je n'aurais jamais pensé voir le jour où je pourrais coder mes propres fonctions PHP. Vous verrez dans le processus de construction de PIE (vous pouvez ajouter des filtres de verbosité à la ligne de commande avec -v -vv etc pour obtenir plus de logs) qu'il s'occupe de beaucoup de choses pour rendre aussi facile l'utilisation d'extensions existantes ou la construction de vos propres extensions. Pour d'autres utilisations passionnantes, je peux voir (par exemple) des extensions personnalisées utilisées pour les constructions de NativePHP qui permettront d'accéder à toutes sortes d'API natives au sein d'un appareil ou d'une machine.