Environnement d'objet Perl

Le Perl Object Environment ( POE ) est une bibliothèque de modules Perl écrits dans le langage de programmation Perl par Rocco Caputo et al.

D'après le CPAN :

« POE a été développé à l'origine comme le cœur d'un serveur d'objets persistants et d'un environnement d'exécution. Il a évolué vers un cadre multitâche et réseau à usage général, englobant et fournissant une interface cohérente avec d'autres boucles d'événements telles que Event et les boîtes à outils Tk et Gtk . »

POE, l' environnement d'objets Perl , peut être considéré comme un petit système d'exploitation modulaire . Un ou plusieurs programmes ou instances POE peuvent être exécutés simultanément et sont généralement bien adaptés au multitâche coopératif . Le package POE se compose d' espaces de noms et d'abstractions qui guident le développement futur de POE dans une convention ouverte de style CPAN .

L'architecture informelle se compose d'un ensemble de couches avec un noyau en dessous. Ce petit noyau représente la couche d'événements qui fonctionne comme la boucle principale de chaque instance POE en cours d'exécution. Le premier appel est adressé au « répartiteur d'événements » - POE::Kernel .

L'espace de noms POE::Kernel contient une suite de fonctions qui sont connectées au noyau lui-même. Ces abstractions de boucle sont conçues d'après l'interface de pont de boucle d'événement standardisée de POE - POE::Loop . Elles peuvent être mélangées et associées selon les besoins pour fournir des services d'exécution et une fonction simplifiée pour la communication interprocessus . Les fonctions de base sont POE::Loop::Event , POE::Loop::Poll et POE::Loop::Select . Sont également disponibles POE::Loop::Tk et POE::Loop::Gtk qui offrent des points d'ancrage vers d'autres ponts de boucle dans l'environnement externe. Si cela ne suffit pas, l'abstraction du noyau POE::Loop fournit des rappels de signal réutilisables, des rappels d'heure ou d'alarme et des rappels d'activité de descripteur de fichier ainsi que des fonctions administratives telles que l'initialisation, l'exécution et la finalisation des boucles d'événements.

Il existe également un framework de packaging de niveau supérieur - POE::Macro et un utilitaire de débogage pour les tester appelé POE::Preprocessor. Ce framework a donné naissance à POE::Macro::UseBytes .

REMARQUE : comme le veut la tradition Perl, POE est également une cible mouvante.

Consultez toujours le CPAN pour voir quelles nouveautés la communauté a placées dans l'archive. (...et rappelez-vous la devise de Perl : « Il y a plus d'une façon de le faire » selon Larry )

Le noyau en cours d'exécution fonctionne via des machines à états finis primordiales construites à partir d'un autre ensemble d'abstractions régies par l' architecture POE::Session . Une POE::Session est presque trivialement définie comme une carte d'événements vers les fonctions, les méthodes de classe et/ou les méthodes d'objet qui les gèrent. Les objets POE::Session contiennent également un espace de stockage partagé par tous ses gestionnaires d'événements, appelé un tas . Quelle que soit la façon dont vous les découpez, les états sont solidement identifiés et clairement définis.

Un gestionnaire d'événements plus complet est une sous-classe POE::Session appelée POE::NFA - un automate fini non déterministe piloté par événements (une machine à états finis plus intelligente ). Ce gestionnaire d'événements passe d'un état strictement défini à un autre en fonction des événements, des sondages, des sélections d'utilisateurs ou d'autres événements externes. Cette machine à états agit pour encapsuler une large gamme de threads génériques pilotés par événements , permettant un suivi beaucoup plus précis le long du chemin d'exécution que la classe relativement informelle POE::Session.

L'exigence suivante du noyau concerne les gestionnaires d'entrées-sorties qui existent dans une seule couche d'E/S appelée Wheels . Les Wheels initient des actions, gèrent les événements de bas niveau qui en résultent et produisent des événements de niveau supérieur pour les sessions qui les utilisent. Les Wheels, comme les Sessions et les Loops, sont construits à partir d'un ensemble uniforme d'abstractions - POE::Wheel - qui reposent sur le noyau. Il existe sept Wheels hautement spécialisés et bien définis dans la distribution de base de POE :

• POE::Wheel::Run - Crée et interagit avec les processus enfants à l'aide de pipe(), fork() et parfois exec(). L'interaction se fait via l'entrée et la sortie standard de l'enfant.
• POE::Wheel::SocketFactory - Un moyen de créer des sockets client et serveur sans bloquer l'attente de leur établissement.
• POE::Wheel::Curses - Un gestionnaire pour les entrées non bloquantes de la bibliothèque d'interface texte Curses . Les composants CPAN tels que Curses::UI::POE et Term::Visual s'appuient dessus.
• POE::Wheel::FollowTail - Suit un fichier en constante évolution, tel qu'un journal ou un document collaboratif, en gardant le contrôle de sa queue.
• POE::Wheel::ListenAccept - Un sous-ensemble de POE::Wheel::SocketFactory utilisé pour écouter les sockets de serveur existants et accepter les connexions des clients distants.
• POE::Wheel::ReadLine - Un analogue non bloquant et piloté par événement de Term::ReadLine.
• POE::Wheel::ReadWrite - Un gestionnaire de fichiers NBIO hautes performances pour POE qui utilise les pilotes et les filtres de POE pour effectuer une lecture et une écriture en mémoire tampon sur les descripteurs de fichiers qui s'appuient sur la couche suivante - le petit système de fichiers de POE.

Les pilotes effectuent le travail réel de lecture et d'écriture des handles de fichiers. Ils sont construits selon les définitions moins abstraites contenues dans le module POE::Driver . Le principal pilote implémenté au moment de la rédaction de cet article est POE::Driver::SysRW - un lecteur/enregistreur de handles de fichiers universel conçu spécialement pour POE::Wheel::ReadWrite.

La couche suivante, construite à partir de POE::Filter et probablement au centre de la plupart des Efficaces d'Obfuscation Perl (voir POE #POE Humor ci-dessous), est l' ensemble POE::Filter :

« Les filtres traduisent entre les flux bruts et des morceaux cuits de dada savoureux. " par `sungo' 

• POE::Filter::Block - analyse les entrées sous forme de blocs de longueur fixe. Côté sortie, il transmet simplement les données sans les endommager.
• POE::Filter::HTTPD - analyse les entrées sous forme de requêtes HTTP et les traduit en objets HTTP::Request . Côté sortie, il prend les objets HTTP::Response et les transforme en quelque chose qui peut être envoyé à un client Web/agent utilisateur.
• POE::Filter::Line - analyse les flux entrants en lignes et transforme les lignes sortantes en flux. C'était très basique, mais des améliorations récentes ont ajouté des fonctionnalités intéressantes comme la détection automatique de saut de ligne.
• POE::Filter::Reference - utilisé pour envoyer des structures Perl entre des programmes POE ou entre POE et d'autres programmes Perl. Du côté entrée, les données gelées (via Storable, FreezeThaw, YAML ou un autre mécanisme de sérialisation) sont dégelées dans des structures de données Perl. En sortie, les références données au filtre sont gelées. Les données peuvent également être compressées sur demande si Compress::Zlib est installé.
• POE::Filter::Stream - ne fait rien. Il transmet simplement les données sans aucune modification.

voir POE sur CPAN pour la liste complète

Plusieurs paquets plus volumineux ont été écrits en POE selon la documentation POE::Component . Ce sont des modules pilotés par événements, dont beaucoup agissent comme de petits démons qui fournissent des services aux paquets plus volumineux auxquels ils appartiennent. Certains d'entre eux facilitent les communications de plus haut niveau entre les modules, en particulier les applications autonomes qui doivent rester indépendantes de la distribution principale de Perl.

En général, les composants POE sont des procédures de haut niveau prêtes à l'emploi qui exécutent des tâches spécifiques de grande envergure. Quelques exemples :

• Component::Server::TCP - un servlet TCP à usage spécifique
• Component::Client::TCP - un client TCP compatible POE
• POE::Component::IRC - un client IRC presque complet.
• POE::Component::Server::IRC - un serveur IRC compatible RFC 2810 à RFC 2813 (en cours de développement)
• POE::Component::UserBase - un servlet d'authentification utilisateur et de persistance des données.

« Les composants POE ont tendance à être des bibliothèques hautement réutilisables qui gèrent des tâches fastidieuses, libérer les programmeurs pour qu'ils puissent se concentrer sur des choses plus intéressantes. Cela devrait toutefois être vrai pour n’importe quelle bibliothèque. 

• Le module Acme::POE::Knee sur le CPAN .
• Un certain nombre d'extensions d'acronymes ridicules à la fin de Qu'est-ce que POE.