Un chat en Pharo : le serveur

GNU/Linux Magazine n° 189 | janvier 2016 | Stéphane Ducasse
Creative Commons
  • Actuellement 0 sur 5 étoiles
0
Merci d'avoir participé !
Vous avez déjà noté cette page, vous ne pouvez la noter qu'une fois !
Votre note a été changée, merci de votre participation !
À l'aide de Teapot, Pharo permet la définition d'un serveur REST en quelques dizaines de lignes. Grâce à lui, vous allez développer rapidement un serveur de chat basé sur HTTP et permettant l'échange de messages entre plusieurs interlocuteurs.

L'objectif de cet article est de vous faire développer en trois classes, un serveur de chat. Cette petite aventure vous permettra de vous familiariser avec Pharo et de voir l'aisance avec laquelle un serveur REST peut être défini. Développée en quelques heures, TinyChat a été conçue comme une application pédagogique.

Avant toute chose, téléchargez Pharo à partir du site officiel du projet (www.pharo.org). Pharo est principalement disponible pour Linux, Mac et Windows. L'installation se résume à la décompression d'un fichier zip. Une fois Pharo lancé, vous devez lui ajouter le framework Teapot.

Vous pouvez charger Teapot en utilisant le  Configuration Browser qui se trouve dans le menu Tools du menu principal. Sélectionnez Teapot et utilisez Install Stable. Une autre solution consiste à utiliser le script suivant :

Gofer it

 smalltalkhubUser: 'zeroflag'

 project: 'Teapot';    

 configuration;    

 loadStable.

Votre environnement de développement est maintenant prêt. La première étape va consister à mettre en place l'élément de base d'un chat : les messages.

1. Architecture et représentation des messages

Nous allons donc construire un serveur de discussion. La communication entre le serveur et son client sera basée sur HTTP et REST. La classe principale sera TCServer. Nous définirons également deux autres classes : la classe TCMessage qui représente les messages échangés (dans le futur, vous pourrez étendre TinyChat pour échanger des éléments plus structurés comme JSON ou STON qui est le format textuel Pharo) et la classe TCMessageQueue qui stocke les messages.

1.1 La classe TCMessage

Un message est un objet très simple avec un texte et un identifiant pour l'émetteur.

Nous définissons la classe TCMessage dans le package TinyChat :

Object subclass: #TCMessage

 instanceVariableNames: 'sender text separator'  

 ClassVariableNames: ''

 category: 'TinyChat'

Les variables d'instances sont les suivantes :

- sender : le login de l'expéditeur ;

- text : le texte du message ;

- separator : un caractère séparateur pour l'affichage.

1.2 Gestion des variables d'instance sender et text

Nous créons les accesseurs suivants :

TCMessage >> sender

 ^sender

TCMessage >> sender: anObject

 ^sender := anObject

TCMessage >> text

 ^ text

TCMessage >> text: anObject

 text := anObject

1.3 Initialisation de la classe

La méthode initialize définit la valeur du caractère séparateur :

TCMessage >> initialize

 super initialize.

 separator := '>'.

La méthode de classe TCMessage class>>from:text: permet d'instancier un message :

TCMessage class >> from: aSender text: aText  

 ^ self new

  sender: aSender;

  text: aText;

  yourself

Le message yourself rend le receveur du message : c'est une manière de s'assurer que le nouvel objet créé sera bien retourné par le message from:text: et non le résultat du message text:.

1.4 Convertir un message en chaîne de caractères

Nous ajoutons une méthode printOn: pour transformer le message en une chaîne de caractères. Celle-ci est constituée des éléments suivants :

- l'identifiant de l'expéditeur ;

- le caractère séparateur ;

- le texte envoyé ;

- un retour à la ligne.

La méthode printOn: est invoquée par la méthode printString. Il est important de comprendre que la méthode printOn: est invoquée par les outils tels que le débogueur ou l'inspecteur d'objets. L'utilisation de printOn: dans vos projets Pharo constitue une aide précieuse pour la mise au point de votre code . En adoptant un formatage adapté, elle facilite considérablement la lecture des données gérées dans votre application.

TCMessage >> printOn: aStream

 aStream

  << self sender;

  << separator;   

  << self text;

  << String crlf

1.5 Construire un message à partir d'une chaîne de caractères

Nous devons également définir deux méthodes pour créer un message à partir d'une chaîne ayant, par exemple, la forme: 'olivier>tinychat est cool'. Tout d'abord, créons une méthode de classe qui sera invoquée de la manière suivante: TCMessage fromString: 'olivier>tinychat est cool', puis la méthode d'instance remplissant les variables de l'objet préalablement créé.

TCMessage class >> fromString: aString  

 ^ self new

  fromString: aString;

  yourself

TCMessage >> fromString: aString

 "Compose a message from a string of this form 'sender>message'."

 | items |

 items := aString subStrings: separator.

 self sender: items first.

 self text: items second.

Maintenant, nous sommes prêts pour la définition du serveur REST.

2. Gestion des messages

Dans le serveur, nous allons ajouter une classe pour gérer une queue de messages. Ce n'est pas vraiment nécessaire, mais cela permet de bien identifier les responsabilités.

2.1 Stockage des messages

Créez la classe TCMessageQueue dans le package TinyChat-Server :

Object subclass: #TCMessageQueue

instanceVariableNames: 'messages'

classVariableNames: ''

category: 'TinyChat-server'

La variable d'instance messages est une collection ordonnée dont le contenu est composé d'instances de TCMessage. Une OrderedCollection est une collection qui s'agrandit dynamiquement lors d'ajouts.

TCMessageQueue >> initialize

 super initialize.

 messages := OrderedCollection new.

2.2 Opérations de base sur la liste des messages

On doit pouvoir ajouter un message avec add:, effacer la liste avec reset et connaître le nombre de messages avec size :

TCMessageQueue >> add: aMessage

 messages add: aMessage

TCMessageQueue >> reset

 messages removeAll

TCMessageQueue >> size

 ^ messages size

2.3 Obtenir la liste des messages à partir d'une position

Lorsqu'un client demande au serveur la liste des derniers messages échangés, il indique au serveur l'index du dernier message qu'il connaît. Le serveur répond alors la liste des messages reçus depuis cet index.

TCMessageQueue >> listFrom: aIndex

 ^ (aIndex > 0 and: [ aIndex <= messages size])

  ifTrue: [ messages copyFrom: aIndex to: messages size ]

  ifFalse: [ #() ]

2.4 Formatage des messages

La classe TCMessageQueue doit pouvoir formater une liste de messages (à partir d'un index) en une chaîne de caractères que le serveur pourra transmettre au client. On ajoute ensuite une méthode à la classe TCMessageQueue pour construire une seule chaîne de caractères à partir de chaque chaîne de caractères produite par chaque message :

TCMessageQueue >> formattedMessagesFrom: aMessageNumber

 ^ String streamContents: [ :formattedMessagesStream |

  (self listFrom: aMessageNumber) do: [ :m |

   formattedMessagesStream << m printString ]]

3. Le Serveur de Chat

Le cœur du serveur est basé sur le framework REST Teapot, permettant l'envoi et la réception des messages. Il maintient également une liste de messages qu'il communique aux clients.

3.1 Définition du routage HTTP

Créez la classe TCServer dans le package TinyChat-Server :

Object subclass: #TCServer

 instanceVariableNames: 'teapotServer messagesQueue'

 classVariableNames: ''

 category: 'TinyChat-Server'

La variable d'instance messagesQueue référence la liste des messages reçus et envoyés par le serveur :

TCServer >> initialize

 super initialize.

 messagesQueue := TCMessageQueue new.

La variable d'instance teapotServer référence l'instance du serveur TeaPot que l'on crée à l'aide de la méthode initializePort:.

TCServer >> initializePort: anInteger

 teapotServer := Teapot configure: {

 #defaultOutput -> #text.

 #port -> anInteger.

 #debugMode -> true}.

 teapotServer start.

Le routage HTTP est défini dans la méthode registerRoutes. Trois opérations sont définies :

- GET messages/count : retourne au client le nombre de messages reçus par le serveur ;

- GET messages/<id:IsInteger> : le serveur retourne les messages à partir de l'index indiqué dans la requête HTTP ;

- POST /message/add : le client envoie un message au serveur.

TCServer >> registerRoutes

 teapotServer

 GET: '/messages/count' -> (Send message: #messageCount to: self);

 GET: '/messages/<id:IsInteger>' -> (Send message: #messagesFrom: to: self);

 POST: '/messages/add' -> (Send message: #addMessage: to: self)

Nous exprimons ici que le chemin /message/count va donner lieu à l'exécution du message messageCount sur le serveur lui-même. Le pattern <id:IsInteger> indique que l'argument doit être exprimé sous forme de nombre et qu'il sera converti en un entier. La gestion des erreurs est construite dans la méthode registerErrorHandlers. Ici, on voit comment est construite une instance de la classe TeaResponse.

TCServer >> registerErrorHandlers

 teapotServer

  exception: KeyNotFound -> (TeaResponse notFound body: 'No such message')

Le démarrage du serveur est confié à la méthode TCServer class>>startOn: qui reçoit le numéro de port TCP en paramètre.

TCServer class >> startOn: aPortNumber

 ^self new

  initializePort: aPortNumber;

  registerRoutes;

  registerErrorHandlers;

  yourself

Il faut également gérer l'arrêt du serveur. La méthode stop met fin à l'exécution du serveur TeaPot et vide la liste des messages.

TCServer >> stop

 teapotServer stop.

 messagesQueue reset.

Comme il est probable que vous exécutiez plusieurs fois l'expression TCServer startOn:, nous définissons la méthode de classe stopAll qui stoppe tous les serveurs en récupérant toutes les instances de la classe.  La méthode TCServer class>>stopAll demande l'arrêt de chaque instance du serveur.

TCServer class >> stopAll

 self allInstancesDo: #stop

3.2 Traitements réalisés par le serveur

La méthode addMessage extrait de la requête du client le message posté. Elle ajoute à la liste des messages une nouvelle instance de TCMessage.

TCServer >> addMessage: aRequest

 messagesQueue add: (TCMessage from: (aRequest at: #sender) text: (aRequest at: #text))

La méthode messageCount retourne le nombre de messages reçus.

TCServer >> messageCount

 ^ messagesQueue size

La méthode messageFrom: retourne la liste des messages reçus par le serveur depuis l'index indiqué par le client. Les messages sont retournés au client sous la forme d'une chaîne de caractères. Ce point sera définitivement à améliorer (JSON ou XML sont plus adaptés si vous voulez faire évoluer ce projet).

TCServer >> messagesFrom: request  

 ^ messagesQueue formattedMessagesFrom: (request at: #id)

Nous en avons fini avec le serveur. À ce stade, nous pouvons le tester un peu. Commençons par le lancer :

TCServer startOn: 8181

Pour émettre des requêtes, nous pouvons utiliser un navigateur ou le client HTTP disponible par défaut dans Pharo (voir résultat en figure 1).

ZnClient new url: 'http://localhost:8181/messages/count' ; get

Les amateurs du shell peuvent également utiliser la commande curl :

curl http://localhost:8181/messages/count

Fig. 1 : Le serveur n'a reçu aucun message.

Dans Pharo, nous pouvons aussi ajouter un message de la manière suivante :

ZnClient new

url: 'http://localhost:8181/messages/add';

formAt: 'sender' put: 'olivier';

formAt: 'text' put: 'Super cool ce tinychat';

post

Conclusion

Nous avons montré que la création d'un serveur REST est extrêmement simple avec Teapot. À ce stade, vous pouvez tester le bon fonctionnement du serveur et pourquoi pas, expérimenter en modifiant certaines méthodes ou en ajoutant de nouvelles fonctionnalités. Certes, le produit est encore brut de fonderie en termes de confort d'utilisation. Pour cette raison, dans le prochain article, vous réaliserez un client graphique pour le serveur. L'objectif sera de concevoir avec un minimum de code, un client de chat basé sur le framework Spec.

Références

[1] Site officiel du projet Pharo : http://www.pharo.org

[2] Site officiel du projet Zinc : http://zn.stfx.eu/zn/index.html

[3] Le framework Teapot :http://smalltalkhub.com/#!/~zeroflag/Teapot

[4] Télécharger le projet TinyChat : http://www.smalltalkhub.com/#!/~olivierauverlot/TinyChat

Pour aller plus loin

Le site du projet Pharo : http://www.pharo.org

L'ouvrage collectif « Pharo par l'exemple », Square Bracket Associates, 2011

L'ouvrage collectif « Deep inside Pharo », Square Bracket Associates, 2013

Tags : Chat, Pharo, serveur