Lier Erlang avec d`autres langages de

16
Lier Erlang avec
d’autres langages
de programmation
Les logiciels actuels, quelle que soit leur taille, sont souvent écrits dans plusieurs lan-
gages de programmation. Généralement, les pilotes de périphériques sont écrits en C et
de nombreux environnements de développement intégrés comme Eclipse sont écrits en
Java ou en C#; les applications web peuvent être développées en Ruby et en PHP. De
son côté, Erlang permet d’offrir une concurrence légère et résistante aux pannes et, pour
manipuler ou analyser efcacement des chaînes de caractères, Perl et Python sont la
norme. Par ailleurs, si la bibliothèque dont vous avez besoin pour résoudre un problème
n’existe pas dans votre langage favori, vous devrez alors choisir entre utiliser une biblio-
thèque externe ou tout recoder vous-même en Erlang1.
La communication entre les langages n’est jamais simple, qu’il s’agisse du langage
naturel ou des langages de programmation. Avec le premier, il faut comprendre com-
ment chaque langue fonctionne – utilise-t-elle des articles? Différencie-t-elle le genre?
Où sont placés les verbes dans une phrase? Il faut également savoir traduire les mots –
le verbe ser du portugais signie-t-il la même chose que "être" en français? (La réponse
est non.) Il en va de même pour les langages de programmation: quel paradigme utili-
sent-ils? Sont-ils fonctionnels, orientés objet, concurrents ou structurés? Est-ce qu’un
entier Java est identique à un entier Erlang? (La réponse est non!)
En outre, cette communication entre les langages n’est pas tout; Erlang/OTP permet
également de communiquer en utilisant XML, ODBC, CORBA, ASN et SNMP, qui
aident Erlang dans son rôle sans cesse croissant de "colle distribuée" pour relier des
programmes monothreads classiques.
1. C’est ce que fait Wrangler, l’outil de refactoring pour Erlang, pour détecter le code dupliqué: il utilise
une bibliothèqueC efcace pour identier les "clones" éventuels dans le code Erlang.
Livre Erlang.indb 361 31/08/10 13:13
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

362 Programmer en Erlang
Présentation du problème
Erlang fournit un certain nombre de mécanismes pour travailler avec plusieurs lan-
gages: un modèle de haut niveau reposant sur des nœuds Erlang distribués, un modèle
de plus bas niveau permettant de communiquer avec un programme externe par un port
et un mécanisme permettant de lier des programmes – les pilotes liés – dans la machine
virtuelle elle-même.
Le modèle de programmation distribuée d’Erlang offre une solution à la fois simple et
souple au problème du fonctionnement des autres langages avec Erlang: les programmes
écrits dans d’autres langages s’exécutent dans d’autres nœuds sur la même machine ou
sur des machines différentes et apparaissent comme des nœuds Erlang distribués qui
envoient et reçoivent des messages. Ces nœuds offrent un environnement dans lequel les
programmes externes peuvent s’exécuter, mais également communiquer avec des nœuds
Erlang. Pour que cet échange avec un programme écrit dans un autre langage fonctionne,
on peut utiliser des ports ou fournir un modèle plus élaboré des primitives de communi-
cation Erlang dans cet autre langage. Dans les deux cas, il faut savoir comment gérer les
types de base et traduire les structures de données composées entre les deux langages.
Dans ce chapitre, nous verrons comment construire des nœuds en Java et en C qui peu-
vent interagir avec Erlang. Nous présenterons également erl_call, qui permet au shell
Unix de communiquer avec un nœud Erlang distribué et qui repose sur la bibliothèque
erl_interface fournie avec Erlang, tout comme le paquetage Java JInterface. Ces
bibliothèques offrent un code et une architecture stables aux dépens de la vitesse pure.
Puis nous expliquerons comment communiquer au moyen des ports et nous donnerons
un exemple d’interaction avec Ruby en nous servant de la bibliothèque erlectricity.
Autres langages
Ce chapitre traite des interactions avec Java, C et Ruby, mais Erlang peut être lié à un
grand nombre d'autres langages de programmation:
• OTP.NET fournit un lien vers la plateforme .NET, via un portage du code de JInter-
face.
• Py-Interface, une implémentation Python d'un nœud Erlang, permet de faire commu-
niquer ces deux langages.
• Le Perl Erlang-Port permet à du code Perl de communiquer avec Erlang via un port.
• PHP/Erlang est une extension PHP fournissant un ensemble de fonctions pour trans-
former un thread PHP en nœud ErlangC.
• Haskell/Erlang-FFI autorise une communication complète et dans les deux sens entre
des programmes écrits en Haskell et en Erlang. Les messages envoyés depuis Haskell
vers Erlang ressemblent à des appels de fonctions et les messages envoyés d'Erlang à
Haskell sont délivrés à des MVar.
• L'interface Erlang/Gambit permet de faire communiquer Scheme et Erlang.
• Distel améliore le mode Erlang d'Emacs en autorisant l'interaction entre Emacs Lisp
et Erlang.
Livre Erlang.indb 362 31/08/10 13:13
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

Chapitre 16 Lier Erlang avec d’autres langages de programmation 363
Pour obtenir une interaction la plus efcace possible, vous pouvez dénir un pilote
lié. Cependant, un pilote lié mal écrit pouvant provoquer des fuites mémoire, ger ou
crasher tout le système d’exécution d’Erlang, ces pilotes doivent être utilisés avec la
plus grande prudence.
Interagir avec Java
Le paquetage Java JInterface offre à Java un modèle de processus et de communica-
tion à la Erlang. Vous pouvez l’utiliser seul pour bénécier de la concurrence de type
Erlang en Java, ou comme composante d’un système distribué mélangeant les deux
langages an d’intégrer des composants Erlang dans un système Java et vice versa.
JInterface est une collection de classes Java dont les noms commencent quasiment
tous par Otp. Cette section décrira les plus utilisées et donnera des exemples d’envoi de
messages et de gestion des types de données entre les deux langages. Vous trouverez
plus d’informations sur JInterface et ses classes Erlang dans la section "Interface
and Communication Applications" de la documentation d’Erlang/OTP. Le l rouge de
cette section sera une réécriture de l’exemple d’appel de procédure distante (RPC) du
Chapitre11.
Nœuds et boîtes aux lettres
Nous avons décrit les nœuds Erlang au Chapitre11, qui a également présenté la pro-
grammation distribuée. Un nœud Erlang est désigné par son nom, constitué d’un iden-
tiant suivi d’un nom d’hôte (au format court ou long) ; chaque hôte peut exécuter
plusieurs nœuds, pourvu que leurs noms soient différents.
La classe OtpNode est la représentation JInterface d’un nœud Erlang:
OtpNode machin = new OtpNode("machin");
Cette instruction crée l’objet Java machin – que nous appellerons un nœud –,qui repré-
sente le nœud Erlang machin qui s’exécute sur la machine sur laquelle elle est exécutée.
Vous pouvez créer un processus sur ce nœud en créant une boîte aux lettres, représentée
par un identiant de processus ou enregistrée sous un certain nom. L’instruction suivante
crée un processus:
OtpMbox mbox = machin.createMbox();
Pour donner un nom à cette boîte, il suft de passer une chaîne en paramètre:
OtpMbox mbox = machin.createMbox("serveurfacto");
L’enregistrement peut également s’effectuer après la création:
mbox.registerName("serveurfacto");
Livre Erlang.indb 363 31/08/10 13:13
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

364 Programmer en Erlang
Dans les deux cas, le processus est enregistré sous le nom serveurfacto. Nous l’avons
nommé ainsi car il agira comme un "serveur de factorielles" en renvoyant la factorielle
des entiers qu’il reçoit aux processus qui les ont envoyés.
Vous pouvez désormais accéder à cette boîte aux lettres par son nom. Si vous avez
également besoin de son identiant de processus – pour un nœud Erlang distant, par
exemple –, utilisez sa méthode self():
OtpErlangPid pid = mbox.self();
Représentation des types Erlang
Le paquetage JInterface contient plusieurs classes pour représenter les différents
types Erlang en Java. Leurs méthodes permettent de convertir les types natifs dans ces
représentations et réciproquement, ce qui est essentiel à l’interaction entre les deux
langages.
Nous avons déjà vu un exemple dans l’instruction précédente: la classe OtpErlang-
Pid produit la représentation Java d’un identiant de processus Erlang. De même,
les classes OtpErlangAtom, ..., OtpErlangTuple, OtpErlangObject permettent de
représenter les atomes, les binaires, les listes, les ports, les références, les tuples et les
termes.
Les types points ottants d’Erlang sont convertis en OtpErlangFloat ou OtpErlang-
Double ; les types entiers en OtpErlangByte, OtpErlangChar, OtpErlangShort,
OtpErlangInt, OtpErlangUInt ou OtpErlangLong, selon la valeur et le signe de la
valeur concernée.
La classe OtpErlangBoolean permet de représenter les deux atomes spéciaux true et
false et les chaînes Erlang – qui ne sont que des listes d’entiers –sont décrites par la
classe OtpErlangString.
Tous les détails de ces classes se trouvent dans la documentation de JInterface; nous
les utiliserons dans la prochaine section et dans l’exemple RPC.
Communication
Les processus Erlang envoient et reçoivent des messages; dans JInterface, ces opé-
rations sont implémentées par les méthodes send et receive d’une boîte aux lettres.
Les messages échangés sont des termes Erlang et sont donc représentés par des objets
OtpErlangObject en Java. L’envoi du message suivant dans le processus mbox:
Pid ! {ok, M}
sera donc traduit par:
mbox.send(pid,tuple);
Livre Erlang.indb 364 31/08/10 13:13
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson

Chapitre 16 Lier Erlang avec d’autres langages de programmation 365
où la variable Java pid correspond à la variable Erlang Pid, et tuple2 représente le
terme Erlang {ok, M}.
Un message est reçu par une instruction de la forme:
OtpErlangObject o = mbox.receive();
Cette instruction est différente d’un receive Erlang car elle n’effectue aucun pattern
matching sur le message. Nous verrons dans l’exemple suivant comment décomposer et
analyser ce message.
Récapitulatif: RPC revisité
Le code Erlang suivant met en place un serveur de factorielles sur le nœud machin de
l’hôte STC:
setup() ->
spawn('machin@STC',monrpc,serveur,[]).
serveur() ->
register(serveurfacto,self()),
factoLoop().
factoLoop() ->
receive
{Pid, N} ->
Pid ! {ok, facto(N)}
end,
factoLoop().
Le serveur reçoit des messages de la forme {Pid, N} et renvoie le résultat {ok,
facto(N)} au processus identié par Pid. Voici le code Java qui effectue le même
travail:
1 import com.ericsson.otp.erlang.*; // Pour JInterface
2 import java.math.BigInteger; // Pour la factorielle
3
4 public class NoeudServeur {
5
6 public static void main (String[] _args) throws Exception{
7
8 OtpNode machin = new OtpNode("machin");
9 OtpMbox mbox = machin.createMbox("serveurfacto");
10
11 OtpErlangObject o;
12 OtpErlangTuple msg;
13 OtpErlangPid de;
2. Si vous programmez en Erlang depuis plusieurs années et que vous soyez troublé par le fait que des
variables comme pid et tuple sont toutes en minuscules, vous n’êtes pas seul. Ce qui est important,
ici, est que vous ne les preniez pas pour des atomes.
Livre Erlang.indb 365 31/08/10 13:13
© 2010 Pearson France – Programmer en Erlang – Francesco Cesarini, Simon Thompson