Forum d'entraide PHPFrance

Bonjour à tous,

Je m'adresse à vous dans l'espoir de trouver une solution qui m'éviterait de développer ce qui me semble être une roue.

Je dois développer un système très classique en ce qui concerne son architecture. Il s'agit d'un système composé d'un "moteur central" et de "connecteurs". Les "connecteurs" permettent au "moteur central" d'interagir avec son environnement, constitué de sources d'information hétérogènes (du point de vue de leurs interfaces d'accès). Autrement dit, les "connecteurs" assurent un "découplage logique" entre le "moteur central" et son environnement.

Les "connecteurs" peuvent prendre deux formes :

• Une solution consiste à implémenter les connecteurs sous la forme de "greffons" (traduction de l'anglais "plugin"). Dans ce cas, le connecteur est un "bout de code (PHP, en l'occurrence) étranger" qui est intégré, à la demande, au code du système central. Le connecteur et le système fusionnent pour ne constituer qu'un seul processus.
• Une autre solution consiste à implémenter les connecteurs sous la forme de processus externes, à l'image des scripts CGIs. Dans ce cas, le connecteur et le système constituent deux processus distincts, qui communiquent via un protocole quelconque.

Des deux solutions évoquées plus haut, je préférons la deuxième, pour les raisons suivantes :

• La première solution impose un langage pour le développement des greffons. Le moteur central étant développé en PHP, les greffons doivent être développés en PHP.
• La deuxième solution offre plus de sécurité, car le connecteur et le système central s'exécutent dans des processus distincts. Un plantage du connecteur ne compromet pas les fonctions du système central.

Bref, la deuxième solution offre un degré de découplage supérieur à celui offert par la première solution. En plus du "découplage logique" (le système central n'intègre pas de logiques étrangères associées à l'environnement), la deuxième solution offre un "découplage technologique". Il en résulte une plus grande capacité d'adaptation et d'évolution. En outre, la deuxième solution est beaucoup plus sûre car la stabilité du "coeur du système" ne peut pas être compromise par un connecteur mal conçu.

La mise en oeuvre de la seconde solution nécessite d'implémenter les éléments fonctionnels suivants :

• Un système robuste de gestion des "forks" (nombre maximum de fils,...).
• Un système robuste et simple qui permet le dialogue entre un processus père et ses fils. L'idéal serait d'implémenter un dialogue via les flux standards (STDIN/STDOUT), à l'image du CGI.

Cela ne semble pas très difficile, a priori. Cela dit, la mise au point d'une interface robuste est plus délicate qu'il n'y paraît à première vue.

Et, d'autre part, je pense ne pas être le premier à envisager ce genre de solution.

Connaissez-vous un module PHP qui remplisse ce besoin?

Merci d'avance,

Denis

Salut,
je ne suis pas certain d'avoir parfaitement saisi l'exposé, mais pour une solution 100% PHP, je me demande si les traits ne seront pas une piste de solution. Un peu de littérature sur le sujet :
- http://truffo.fr/2010/04/traits-php-lel ... rizontale/
- http://blog.runpac.com/post/php-point-sur-traits-trunk
- http://simas.posterous.com/new-to-php-54-traits
Ce n'est pas encore implémenté dans la dernière version stable de PHP à ce jour, mais ça arrive.

Bonjour,

Je ne pense pas que PHP permettent de faire de fork. Tu peux regarder les fonction exec() et similaire pour voir si tu peux contourner le problème.

Le moyen le plus simple pour la connexion entre les processus serait que tes programmes alimentent une (ou plusieurs) table et que le programme maitre exploite les données par simple lecture de cette table.

@Cyrano

J'ai consulté la documentation sur les traits. C'est intéressant. Mais cela ne répond pas au besoin.

Grosso-modo, je développe, en PHP, un moteur, et je souhaite que ce moteur puisse exécuter des fonctions (= des scripts) développées avec un autre langage que PHP.

Pour faire une analogie avec Apache : Apache est développé en C. Cela dit, Apache peut exécuter des fonctions (des scripts CGIs, en l'occurrence) développées avec n'importe quel langage (C, PHP, Perl, Bash, Python, TCL,...). Les scripts exécutés par Apache doivent seulement implémenter l'interface CGI.

Je pourrais utiliser un simple appel système "exec()", et récupérer le code de retour du processus, ainsi que le contenu de sa sortie standard. C'est probablement la solution que je vais choisir si je ne trouve rien de plus "raffiné".

Néanmoins, je me dis que, peut-être, il existe un module PHP spécifique pour répondre à ce besoin.

A+

Comme l'a souligné mere-teresa, ça sent le DesignPattern Commande : malheureusement je maitrise pas du tout celui-ci et je n'en ai que de vagues notions, mais sommairement ton moteur « passe une commande » sans avoir même besoin de connaitre les détails d'implémentation de ladite commande, il y a de l'encapsulation à mettre en place et tes processus externe pourraient être dans d'autres langages pour autant que la commande soit en mesure de lancer leur exécution.

Désolé de ne pouvoir préciser davantage

@Mazarini

Pour information, PHP permet de lancer des "forks" (voir la fonction pcntl_fork()). Cela dit, dans l'hypothèse selon laquelle j'utilise cette possibilité, il me faut aussi développer la mécanique nécessaire pour gérer les fils (dialogue, timeout,...). Ce n'est pas très difficile, mais c'est délicat. Donc si quelqu'un a déjà développé un outil qui fait le travail... autant l'utiliser

A+

En lisant la description j'ai pensé à http://components.symfony-project.org/event-dispatcher/ ?
Mais en relisant plus attentivement, je crois que ce n'est pas du tout ça.

Est-ce que ton système pourrait se retrouver dans un des design patterns du GoF ?

Salut,

Effectivement, Symfony ne répond pas au besoin. Cela dit, ce lien est très intéressant. Je vais certainement trouver une utilité à cette librairie.

En fait, mon besoin n'est, a priori, pas lié à un problème de conception logicielle.

La question de fond est la suivante : Gérer et faire dialoguer des processus apparentés. Le processus père serait écrit en PHP. Les processus fils, eux, seraient issus d'un appel système "pcntl_fork()", mais le processus fils (lancé via "pcntl_exec()") serait écrit dans n'importe quel langage.

En résumé : pcntl_fork() (on crée un fils) suivit de pcntl_exec() (le processus "lancé" s'exécute dans l'espace du processus "lanceur"). Il s'agit de la stratégie d'Apache.

Ensuite il faut :

• Gérer l'exécution simultanée de plusieurs fils (nombre maximum, timeout,...).
• Développer un système qui permette aux fils de renvoyer simplement des données au père (ex: CGI).

Je pourrais utiliser un simple appel système "exec()", et récupérer le code de retour du processus, ainsi que le contenu de sa sortie standard. C'est probablement la solution que je vais choisir si je ne trouve rien de plus "raffiné".

Néanmoins, je me dis que, peut-être, il existe un module PHP spécifique pour répondre à ce besoin.

A+

Comme l'a souligné mere-teresa, ça sent le DesignPattern Commande : malheureusement je maitrise pas du tout celui-ci et je n'en ai que de vagues notions, mais sommairement ton moteur « passe une commande » sans avoir même besoin de connaitre les détails d'implémentation de ladite commande, il y a de l'encapsulation à mettre en place et tes processus externe pourraient être dans d'autres langages pour autant que la commande soit en mesure de lancer leur exécution.

Désolé de ne pouvoir préciser davantage

Salut,

Je te remercie pour ta réponse. Cela dit, je pense que je me suis mal exprimé. Le besoin n'est, à priori, pas lié à une question de conception logicielle. Le problème est plus lié au "système" : Gérer et dialoguer avec des processus fils.

Je pense me tourner vers une solution similaire à celle décrite dans le document ci-dessous, qui traite de Perl - utilisation de de "open()" et de "exec()" (voir le beau schéma) :

http://articles.mongueurs.net/magazines/linuxmag55.html

A+

Bonjour,

En me baladant dans la doc php, j'ai trouvé la fonction proc_open() (http://fr.php.net/manual/fr/function.proc-open.php) qui est succeptible de t'intéresser. Ca semble se rapprocher du fork et des pipes.

Il y a un exemple dans la doc :

<?php
$descriptorspec = array(
   0 => array("pipe", "r"),  // // stdin est un pipe où le processus va lire
   1 => array("pipe", "w"),  // stdout est un pipe où le processus va écrire
   2 => array("file", "/tmp/error-output.txt", "a") // stderr est un fichier
);

$cwd = '/tmp';
$env = array('quelques_options' => 'aeiou');

$process = proc_open('php', $descriptorspec, $pipes, $cwd, $env);

if (is_resource($process)) {
    // $pipes ressemble à :
    // 0 => fichier accessible en écriture, connecté à l'entrée standard du processus fils
    // 1 => fichier accessible en lecture, connecté à la sortie standard du processus fils
    // Toute erreur sera ajoutée au fichier /tmp/error-output.txt

    fwrite($pipes[0], '<?php print_r($_ENV); ?>');
    fclose($pipes[0]);

    echo stream_get_contents($pipes[1]);
    fclose($pipes[1]);

    // Il est important que vous fermiez les pipes avant d'appeler
    // proc_close afin d'éviter un verrouillage.
    $return_value = proc_close($process);

    echo "La commande a retourné $return_value\n";
}
?>

@Mazarini

Salut,

Je te remercie pour ton intervention. Il me semble que tu as trouvé la solution. L'utilisation de cette fonction apporte une solution à la partie la plus délicate du développement.

Je vais tenter le coup. Et je vous tiens informé.

A+

Et pourtant, ca avait mal commencé :

...Je ne pense pas que PHP permette de faire de fork...