Dans ce TD nous allons inclure le jeu de Puissance 4 que nous avons développé précédemment dans une application multi-utilisateurs, permettant de jouer des parties avec des adversaires distants. Nous allons nous servir de la base de données MySQL fournie par Cloud 9 pour le stockage des données côté server, et du système de sessions de Silex pour garder l’état de la connexion.
Pour réaliser une interface fluide et responsive, l’utilisation de
AJAX s’impose. Mais, dans une application web de ce type, il n’est pas
suffisant d’avoir des requêtes asynchrones : il est aussi nécessaire
d’avoir des événements asynchrones générés par le serveur. Nous
allons utiliser l’API EventSource
pour réaliser ce server
push. Allez voir la version pour Silex pour un
exemple d’application simulant le server push avec du short
polling.
Les références pour ce TD sont :
- Les leçons sur les sessions et sur les DBAL,
- La doc de
express-session
sur les sessions, - La doc de
mysql
, - La référence MySQL.
- La page du MDN sur XMLHttpRequest,
- Les pages du MDN sur AJAX,
- Ce
tutoriel sur l’utilisation de
EventSource
avec Node.js, - Ce
tutoriel sur l’utilisation de
EventEmitter
.
Des références optionnelles, si vous décidez d’utiliser un autre DBAL que Doctrine :
Préparer son espace de travail
Comme d’habitude, on va partir d’un clone de http://github.com/defeo/aws-project. Commencez par démarrer le serveur MySQL en tapant la commande
mysql-ctl start
Vous pouvez arrêter à tout moment le server MySQL avec
mysql-ctl stop
et le relancer avec
mysql-ctl restart
Si vous n’arrêtez pas le serveur à la fin de la session, il sera encore actif lors de votre prochaine connexion à l’espace de travail.
L’interface d’administration de bases de données PHPMyAdmin est également disponible dans Cloud9. Installez-la avec la commande
phpmyadmin-ctl install
Elle sera accessible à l’adresse
https://....c9users.io/phpmyadmin
Le nom d’utilisateur est votre identifiant Cloud9 (tronqué à 16
caractères), votre mot de passe est vide. Une base de données nommée
c9
a été automatiquement créé pour vous. Vous pouvez l’utiliser pour
vos applications, ou vous pouvez créer d’autres bases de données.
Note: PHPMyAdmin est exécuté par le même serveur apache qui exécute les applications PHP. Lorsque vous lancez une application Node.js, le serveur Apache est arrêté et PHPMyAdmin devient indisponible.
Pour lancer à nouveau PHPMyAdmin, arrêtez votre serveur Node.js, et
lancez à nouveau le serveur Apache en exécutant n’importe quelle
application PHP (par exemple, example.php
). Pour faciliter le
lancement de PHPMyAdmin, vous pouvez créer une run configuration :
menu « Run → Run configurations → New run configuration », puis
sélectionnez « Runner: Apache httpd » et donnez un nom à la
configuration. À partir de maintenant, cette configuration sera
disponible avec un clic droit sur le bouton « Run », depuis
n’importe quel fichier.
Alternativement, Cloud9 supporte une autre technique, à la mise en place assez simple, permettant de faire tourner un serveur Node en même temps qu’un serveur Apache.
-
Connectez-vous à PHPMyAdmin. Dans le database
c9
(ou dans un nouveau database), créez une table nomméeusers
. La table doit contenir les champs suivants :login
: typevarchar(255)
, clef primaire,pass
: typevarchar(255) NOT NULL
,couleur1
: typevarchar(255)
,couleur2
: typevarchar(255)
,parties
: typeint
, non signé,gagnees
: typeint
, non signé.
-
Ajoutez deux utilisateurs à la table, avec les valeurs que vous voudrez.
Nous sommes maintenant prêts à étendre notre jeu de Puissace 4. Chacune des sections qui suivantes est consacrée à une page de l’application (une vue, en jargon).
Le point d’entrée de l’application va être un fichier app.js
. Vous
êtes cependant libres de distribuer votre logique sur plusieurs
fichiers, importés dans app.js
avec la directive require
(voir la
doc de Node.js sur les modules).
Liste des utilisateurs
Commencez par installer le module mysql
avec la commande
npm install mysql
Cette vue est la plus simple : elle permet d’afficher la liste de tous
les utilisateurs. On rappelle que, avant de pouvoir accéder à la base
de données, il est nécessaire de configurer le module mysql
. Le code
suivant permet de configurer votre application avec les paramètres de
C9.
var mysql = require('mysql');
var db = mysql.createConnection({
host : process.env.IP, // pas touche à ça : spécifique pour C9 !
user : process.env.C9_USER.substr(0,16), // laissez comme ça, ou mettez
// votre login à la place
password : '',
database : 'c9' // mettez ici le nom de la base de données
});
Ensuite le DBAL sera accessible via l’objet db
.
-
Dans
app.js
ajoutez une route pour l’URL/userlist
. Elle doit récupérer l’ensemble des lignes de la tableusers
, et en afficher les colonneslogin
,parties
,gagnees
etcouleur1
sous forme de tableau HTML. On rappelle que le résultat de la requête est passé à la callback de la méthodequery
. -
Remplacez le texte de la case correspondante à
couleur1
par un rectangle coloré de cette même couleur. Si la couleur vautNULL
, utilisez une couleur par défaut. Le résultat pourrait ressembler à cela.Joueur Parties Gagnées Colueur préférée Kasparov 10 3 Karpov 100 99 Suggestion : pour le rectangle coloré, vous pouvez utiliser un
<span>
avec une hauteur et une largeur fixes et la propriétédisplay: inline-block
.
Création des utilisateurs
Nous passons maintenant à une vue qui permet d’ajouter des utilisateurs à la table. Ceci va nous permettre de nous familiariser avec des fonctionnalités avancées de la DBAL.
-
Ajoutez une route de type GET pour l’URL
/signup
. Elle doit présenter un formulaire d’enregistrement permettant de renseigner un login, un mot de passe, une couleur préférée et une couleur secondaire. Le formulaire doit utiliser la méthode POST et renvoyer sur cette même URL (laisser le champsaction
vide suffit). -
Modifiez la route
/signup
pour accepter aussi des requêtes de type POST (rappel : utiliserapp.all()
). Vous pouvez tester le type de la requête avecreq.method
.Lorsque la requête est de type POST, récupérez les valeurs du formulaire et insérez une nouvelle ligne dans la table
users
, seulement si le login et le mot de passe ne sont pas vides (les colonnesparties
etgagnees
doivent démarrer à zéro).Pour réaliser une insertion on utilise la méthode
query
comme pour toute autre requêtedb.query('INSERT INTO users VALUES (?, ?, ...)', [...], function(err, result) { ... });
Si l’insertion réussit, le paramètre
result
contient des informations sur la requête (nombre de lignes insérés, etc., vous pouvez l’examiner avecconsole.log
), eterr
vautfalse
. Si l’insertion échoue,err
contient un objet décrivant l’erreur, alors queresult
estundefined
.- Si l’insertion de l’utilisateur a réussi, rédirigez vers l’URL
/userlist
(avecres.redirect
). - Si l’insertion a raté, présentez à nouveau le formulaire, avec un message d’erreur. Ne faites pas de redirection dans ce cas ; un template vous permettra d’afficher le message d’erreur seulement si nécessaire.
Testez et observez les échanges de requêtes avec l’outil « Réseau » de votre browser.
- Si l’insertion de l’utilisateur a réussi, rédirigez vers l’URL
-
Tester uniquement
result
ne donne pas assez d’information. Essayez, par exemple, d’insérer un utilisateur qui existe déjà, et observez les valeurs deerr
etresult
(dans la console).Repérez le code d’erreur MySQL qui correspond à un login dupliqué. Faites en sorte que votre gestionnaire affiche un message d’erreur significatif lorsque l’utilisateur demande un login déjà existant.
Connexion
Maintenant nous pouvons passer à l’authentification. Puisqu’il s’agit
du point d’entrée de l’application, elle sera servie à l’URL
/
. Après une connexion réussie, l’utilisateur sera redirigé vers
/userlist
.
À ce stade il devient nécessaire de garder chez le serveur l’information que l’utilisateur s’est correctement identifié : en effet, on veut que le mot de passe soit saisi une seule fois au début d’une session. C’est pourquoi entrent en jeu les sessions.
Comme déjà vu dans la leçon sur les sessions, avant de pouvoir utiliser les sessions il faut configurer l’application avec
var session = require('express-session');
app.use(session({ secret: '12345' }))
Ensuite la session sera disponible dans l’objet req.session
.
-
Modifiez le gestionnaire de l’URL
/
pour qu’il affiche un formulaire similaire à celui ciJoueur : mot de passe : -
Comme pour l’URL
/signup
, le gestionnaire pour/
se comportera différemment selon si la requête est de type GET ou POST. Dans le deuxième cas, il doit vérifier avec la BD que le couple login/password est correct, et, en cas affirmatif,- Stocker dans la session le login de l’utilisateur, son score et ses couleurs préférées ;
- Rédiriger vers
/userlist
.
-
Modifier
/userlist
pour qu’il redirige sur/
lorsque l’utilisateur n’est pas authentifié. -
Ajoutez une route
/logout
permettant de se déconnecter. Pour cela, il suffit de mettre une valeur spéciale dans la session (par exemple, le login du joueur ànull
). Lorsque les gestionnaires détecteront cette valeur spéciale, il traiteront la requête comme si le client ne s’était jamais identifié. -
Ajoutez un lien vers
/logout
dans la vue/userlist
.
Utilisateurs en ligne
Contrairement à PHP et à d’autres langages exécutés par un serveur web (CGI), Node.js est un serveur indépendant. Ceci implique que la mémoire globale d’une application Node est partagée par toutes les requêtes, ce qui fournit un mécanisme autre que les sessions pour le stockage de valeurs entre une requête et une autre.
Contrairement aux sessions, ce stockage ne sera pas attaché à un seul client, mais à toute l’application. Le modèle mono-thread à boucle d’évènements de Node.js garantit qu’il n’y aura pas de race conditions lorsque deux gestionnaires de requête veulent accéder à la même zone de mémoire.
Nous allons utiliser cette spécificité de Node pour garder en mémoire une liste des utilisateurs connectés. Cette information sera ensuite transmise aux clients via AJAX.
-
Dans votre application, créez une variable globale (en dehors de tout gestionnaire)
connectes
. Cette variable va contenir la liste des utilisateurs connectés. -
Modifiez le gestionnaire de
/userlist
pour qu’il affiche uniquement les utilisateurs connectés. -
Modifiez les gestionnaires de
/
et/logout
pour qu’ils mettent à jour la variableconnectes
lorsque un utilisateur se connecte ou se déconnecte.
Testez votre application avec plusieurs browsers (au moins deux, il est aussi possible d’utiliser le mode navigation privée de Firefox ou Chrome pour avoir plusieurs fenêtres avec des sessions différentes) ; vérifiez que la liste des utilisateurs correspond bien aux utilisateurs connectés.
Mise à jour dynamique de la liste des utilisateurs
Il est maintenant temps de faire entrer AJAX dans notre application. Nous allons nous en servir pour mettre à jour dynamiquement la liste des utilisateurs.
-
Créez un gestionnaire pour l’URL
/api/userlist
. Il doit récupérer la liste des utilisateurs connectés de la base de données, et l’envoyer au format JSON. Pour cela vous pouvez utiliser la méthoderes.json
qui prend en paramètre un objet JavaScript et qui crée une réponse JSON à partir de celui-ci. Par exemple, le gestionnaireapp.get('/api/fruits', function(req, res) { var data = { fruits: ['banana', 'apple'], how_many: 2 }; res.json(data); });
renvoie la réponse JSON
{ "fruits": ["banana", "apple"], "how_many": 2 }
Testez le gestionnaire avec le browser. Analysez les entêtes HTTP envoyées par le serveur, en particulier le
Content-Type
avec les dev tools. -
Ajoutez dans la page
/userlist
un bouton « Mettre à jour ». Lorsque le bouton est cliqué, une requête AJAX est envoyée vers/api/urserlist
. Lorsque la réponse est reçue, le tableau des utilisateurs en ligne est mis à jour avec le contenu de la réponse JSON.Puisque vous vous attendez à une réponse au format JSON, vous pouvez initialiser l’objet
XMLHttpRequest
avecxhr.responseType = 'json'
. Dans l’exemple précédent, le codexhr.responseType = 'json'; xhr.onload = function() { for (f in xhr.response.fruits) { console.log(f); } }
Écrit dans la console
banana apple
-
Remplacer le bouton « Mettre à jour » avec une minuterie qui met à jour la liste toutes les 2 secondes (utiliser la fonction
setInterval
).
Vous avez maintenant une application simulant le server push avec du short polling.
Du short polling à EventSource
Comme annoncé, nous allons utiliser l’API EventSource
pour réaliser
le server push. Dans cette section nous allons voir comment
remplacer les requêtes AJAX de la section précédente par cette API.
On rappelle le fonctionnement de EventSource
. Il s’agit d’une
connexion persistante entre le client et le server, sur laquelle le
server émet des données textuelles à tout moment. Dans la suite on va
appeler event source le gestionnaire de la connexion du côté
serveur ; il sera attaché à une URL par le router, comme un quelconque
gestionnaire. L’API EventSource
permet au client de déclencher un
événement JavaScript à chaque fois que des nouvelles données sont
envoyées par le server.
Une réponse HTTP typique d’une event source ressemble à cela :
HTTP/1.1 200 OK
Cache-Control: no-cache
Content-Type: text/event-stream
X-Powered-By: Express
transfer-encoding: chunked
Connection: keep-alive
data: Un message anonyme
event: toto
data: Un message de type 'toto'
id: 2
event: toto
data: Un message avec un identifiant
data: sur plusieurs lignes
On voit que les messages sont précédés par le mot clef data:
et
terminés par un double retour à la ligne. Les messages peuvent
optionnellement être précédés par un champs event:
et/ou un champs
id:
, permettant respectivement d’assigner un nom et un
identifiant au message (ce n’est pas très différent des concepts de
classe et id en CSS, respectivement).
Du côté client, c’est très simple d’initialiser une connexion de ce
type : il suffit de créer un objet de type EventSource
en lui
passant l’URL de l’event source.
var evt = new EventSource('/api/notifications');
Pour réagir aux messages du server, il suffit d’enregistrer un
gestionnaire d’événements. Il y a deux types d’événements : les
messages anonymes, qui engendrent un événement de type 'message'
evt.addEventListener('message', function(e) {
console.log(e.data);
});
et les messages avec nom, qui engendrent un événement du même type que le nom du message
evt.addEventListener('toto', function(e) {
console.log(e.data);
});
Dans les deux cas, le corps du message est disponible dans le champ
.data
de l’objet Event
.
Du côté server, cela ne prend que quelques lignes de Node.js pour créer une event source. Voici un exemple qui écrit l’heure courante toutes les secondes.
app.get('/my-event-source', function(req, res) {
// On initialise les entêtes HTTP
res.set({
'Content-Type': 'text/event-stream',
'Cache-Control': 'no-cache',
'Connection': 'keep-alive'
});
// On envoye les entêtes
res.writeHead(200);
// Toutes les secondes, on envoie l'heure.
// On garde une référence au timer pour pouvoir l'arrêter.
var timer = setInterval(function() {
var date = Date();
console.log(date);
res.write('event: date\n');
res.write('data: ' + date + '\n\n');
}, 1000);
// Lorsque le client ferme la connexion, on arrête le timer
// (pour éviter d'encombrer la mémoire de l'application)
req.on('close', function() {
clearInterval(timer);
});
});
-
Transformez le gestionnaire
/api/userlist
en un event source. Toutes les 2 secondes, il écrit sur sa sortie la liste des utilisateurs au format JSON.Note : Vous ne pouvez plus utiliser
app.json
pour écrire les données, car cela fermerait la connexion. À la place, vous pouvez utiliser la fonctionJSON.stringify()
qui transforme un objet JavaScript en une chaîne de caractères au format JSON. -
Modifiez la page
/userlist
pour utiliserEventSource
à la place du short polling. Pour transformer les messages du server en des données JavaScript, vous pouvez utiliser la fonctionJSON.parse
.
Utiliser les événements dans Node.js
À ce stade, notre application ne fait plus du short polling par le client, mais elle reste très inefficace : le polling a été déplacé dans le server, ce qui ne diminue que marginalement le surcoût de communication.
Heureusement, le noyau de Node.js est basé sur les événements. Ceci nous permet de n’écrire sur la sortie du event source que lorsque il est nécessaire : à chaque login ou logout.
L’objet qui permet de générer des événements en Node.js est
events.EventEmitter
. Comme
le nom l’indique, un EventEmitter
est un objet capable d’émettre des
événements : on peut lui attacher autant de gestionnaires
d’événements que l’on souhaite, ceux-ci seront exécutés à chaque fois
que le EventEmitter
émet un événement.
On crée un objet de type EventEmitter
par un new
, comme tout autre
objet. Ses deux méthodes principales sont .emit()
qui permet
d’émettre un événement, .on()
qui permet d’ajouter un gestionnaire
d’événements, et .removeListener()
qui permet d’en supprimer
un.
Dans l’exemple qui suit, on émet un événement de type 'pinged'
à
chaque fois que l’URL /ping
est visitée. Un gestionnaires très
simple est attachés à l’événement, et d’autres gestionnaires peuvent
être ajoutés par la route /logger/...
.
var evt = require('events');
// On crée l'émetteur d'événements
var an_emitter = new evt.EventEmitter();
// On attache un gestionnaire d'événements très simple
an_emitter.on('pinged', function() {
console.log('pinged');
});
app.get('/ping', function(req, res) {
// On émet un événement 'pinged'
an_emitter.emit('pinged');
});
// On ajoute un gestionnaire de plus pour
// l'événement 'pinged'.
app.get('/logger/:id', function(req, res) {
an_emitter.on('pinged', function() {
// remarquez l'utilisation d'une clôture pour
// accéder au paramètre `req` de la portée externe.
console.log(req.params.id + ': pinged');
});
res.send(200);
});
-
Testez ce code en visitant les urls
/ping
et/logger/...
. -
Créez un
EventEmitter
global pour votre application, qui va émettre des événements à chaque fois qu’un utilisateur se connecte ou se déconnecte.Modifiez les gestionnaires de
/
et/logout
pour émettre un événement lorsque un utilisateur s’est connecté ou déconnecté avec succès. -
Modifiez l’event source à l’URL
/api/userlist
. Il ne doit écrire sur sa sortie que lorsque leEventEmitter
émet un événement de login ou de logout.
Bravo, vous avez réussi à écrire votre première application web
totalement asynchrone. Pour une utilisation intensive de
EventSource
, il peut être intéressant d’utiliser des modules pour
Node.js qui encapsulent la logique d’un event source et qui
fournissent une API simplifiée. Aucun module n’a atteint suffisamment
de popularité sur NPM pour éclipser les autres, mais celui qui nous
semble le plus intéressant est
sse-nodejs.
Commencer une partie
Enfin nous arrivons à la partie de Puissance 4. Pour pouvoir
rencontrer un adversaire, il va falloir définir un protocole
d’invitation à faire une partie. Le même canal EventSource
utilisé
dans la partie précédente va nous permettre d’échanger ces messages,
l’entête event:
va nous permettre de distinguer les mises à jour sur
la liste des utilisateurs des autres messages.
Le protocole d’invitation va se dérouler comme suit :
-
Le joueur 1 clique sur l’adversaire qu’il souhaite défier. Une requête est envoyée à l’url
/api/challenge/...
. -
Le joueur 2 est notifié de l’invitation par le
EventSource
. L’interface lui propose d’accepter ou de décliner l’invitation. Le choix de l’utilisateur est envoyé à l’url/api/respond/...
. -
Si le joueur 2 a refusé la partie, le joueur 1 est notifié par le
EventSource
, et tout revient comme avant l’invitation.Sinon, le joueur 1 et le joueur 2 sont notifiés du début de la partie par le
EventSource
, un identifiant de la partie leur est transmis par ce canal. L’interface JavaScript charge le plateau de jeu et la partie commence.
Nous donnons maintenant dans les détails de l’application.
-
À chaque objet utilisateur de la liste
connectes
, ajoutez-
un champ
emitter
qui va contenir un pointeur vers unEventEmitter
, servant à notifier l’utilisateur. -
un champ
partie
qui va pointer vers un objet partie si le jouer participe à une partie, ounull
si le jouer n’est occupé dans aucune partie.
Dans le gestionnaire
/
, remplissez le champ emitter avec un nouveauEventEmitter
créé pour cette session. Dans le gestionnaire/logout
détruisez l’objet pointé paremitter
. Rappel : le mot clefdel
sert à détruire des objets en JavaScript. -
-
Créer un gestionnaire pour
/api/challenge
qui permet à l’utilisateur connecté d’inviter un adversaire à jouer une partie. Dans la suite on va appeler ces deux utilisateurs le challenger et le challengé.Le gestionnaire connaît le login du challenger par la session courante. Pour le challengé, il doit prendre en paramètre son login. Vous avez trois possibilités pour passer ce paramètre au gestionnaire :
-
À travers l’URL, en utilisant une route dynamique :
app.get('/api/challenge/:login', function() {...});
-
À travers un paramètre dans le query string, par exemple
/api/challenge?login=...
, -
À travers le corps d’une requête POST (probablement le moins pratique).
Lorsqu’il est exécuté, le gestionnaire vérifie les champs
partie
des deux joueurs.-
Si l’un des deux est déjà invité ou en train de jouer une partie, le gestionnaire renvoie une erreur
412 Precondition Failed
. On rappelle que pour envoyer un code d’erreur arbitraire on faitres.send(412, 'Message d'erreur');
-
Si les deux utilisateurs sont libres, le gestionnaire assigne un nouvel objet aux champs
partie
des deux joueurs. L’objet doit tenir trace de l’état de la partie (invité, accepté, refusé, etc.), des deux participants et du déroulement de la partie (plateau de jeu).Il notifie ensuite le challengé en émettant un évènement sur son
emitter
, décrivant l’invitation (nom du challenger)Enfin le gestionnaire renvoie un message de succès (du texte simple suffit, par exemple un id de la partie).
-
-
Dans la page
/userlist
, ajoutez un lien sur chacun des logins (à l’exception du login de l’utilisateur courant) qui permet d’inviter le joueur à jouer. Le lien doit être affiché en bleu si l’utilisateur est disponible, en rouge et pas clicable si l’utilisateur est occupé dans une autre partie.Lorsque le lien est cliqué, vous devez déclencher une requête AJAX vers l’URL
/api/challenge...
, qui permet de défier le joueur cliqué. Pour intercepter un clic sur un lien, et éviter que le navigateur suive le lien, il faut utiliser le gestionnaire de l’événementclick
, et utiliser.preventDefault()
, comme cecia.addEventListener('click', function(e) { // Envoyer la requête AJAX ... e.preventDefault(); });
Prévoyez une zone d’affichage pour notifier que l’invitation a été envoyée. Mettez cette zone à jour après l’envoi de la requête AJAX.
-
Modifiez le event source
/api/userlist
pour qu’il envoie un événement de typeinvitation
, lorsque une invitation a été notifiée sur sonemitter
. -
Modifiez la page
/userlist
pour qu’elle notifie l’utilisateur lorsqu’il a été invité à une partie et pour qu’elle lui propose d’accepter ou de refuser. Le choix de l’utilisateur est envoyé par une requête AJAX à l’URL/api/respond
. Pour éviter des conflits, il peut être utile de passer en paramètre le login de l’adversaire ou l’id de la partie. -
Écrivez le gestionnaire de
/api/respond
. Il doit- Modifier l’état de la partie ou bien mettre les champs
partie
des joueurs concernés ànull
, selon le choix du challengé. - Émettre un évènement de refus ou de début partie sur les
emitter
des deux joueurs, selon le choix du challengé. - Renvoyer un code de succès ou d’erreur.
- Modifier l’état de la partie ou bien mettre les champs
-
Modifiez le event source
/api/userlist
pour qu’il transmette les évènements de refus ou de début partie qui lui ont été notifiés par leemitter
.Pour une meilleure gestion des conflits, vous pouvez passer un id de la partie dans l’évènement début de partie.
-
Modifiez la page
/userlist
:- Lorsque elle reçoit un événement de refus, elle affiche un message de notification et vient à l’état initial.
- Lorsque elle reçoit un événement de début partie, elle cache la liste des utilisateurs et charge le plateau de jeu de puissance 4.
Vérifiez que votre application se comporte comme attendu : les utilisateur sont bien notifiés des invitations, acceptations, refus, l’état des tables reste cohérent, aucun utilisateur reste bloqué dans un état inconsistant.
Jouer une série de parties
Nous arrivons à dernière partie de notre application : le jeu. Les indications vont devenir plus sommaires pour vous permettre d’explorer en détail AJAX et le server push.
-
Modifiez le plateau de jeu pour qu’il affiche les noms des deux joueurs participant à la partie, et qu’il utilise leurs couleurs préférées pour représenter les pions. Ces informations se trouvent dans la session et dans les variables globales.
En plus, la page doit afficher à quel joueur c’est le tour de jouer. Normalement, c’est le joueur challengé qui commence.
-
Modifiez votre jeu de Puissance 4. Lorsque le joueur clique sur une case, elle exécute l’une de ces deux actions :
- Si c’est le tour du joueur et le coup est valide, une requête
AJAX est envoyée à l’URL
/api/play
, avec le détails sur le coup joué. Lorsque la requête retourne avec succès, le plateau est mis à jour et le tour passe à l’adversaire. - Sinon, elle affiche un message d’erreur.
- Si c’est le tour du joueur et le coup est valide, une requête
AJAX est envoyée à l’URL
-
Créez le gestionnaire de l’URL
/api/play
. Si le coup joué n’est pas valide, il renvoie un code d’erreur. Sinon- Il met à jour la représentation du plateau sur le serveur ;
- Il met à jour le tour ;
- Il émet un événement sur le
emitter
de l’adversaire ; - Il renvoie un code de succès avec une représentation JSON du plateau.
-
Les vérifications de fin de partie ne peuvent pas être la responsabilité de l’un ou de l’autre joueur. Ce doit être le serveur qui vérifie après chaque coup si la partie est terminée, et notifie les joueurs en conséquence.
Récrivez la logique qui teste la fin de la partie du côté serveur. Lorsque une partie est terminée, mettez à jour les champs
parties
etgagnees
des utilisateurs. -
Lorsque une partie est terminée, donnez à chacun des joueurs la possibilité d’arrêter ou de faire une nouvelle partie.
Lorsque on démarre une nouvelle partie, c’est le joueur qui n’a pas commencé la partie précédente qui démarre.
Lorsque on arrête, les champs
partie
des deux joueurs sont mis ànull
.
Vérifiez que la logique de l’application fonctionne correctement : chaque utilisateur peut jouer uniquement à son tour, aucun utilisateur peut se trouver dans un état inconsistant, l’état des plateaux affichés au joueurs correspond à l’état du plateau dans la base de données.
Pour aller plus loin (optionnel)
On donne ici quelques idées pour développer davantage votre application. Rien n’est obligatoire, mais cela vous permettra d’approfondir votre connaissance des applications web.
-
Dans
/signup
, demandez deux fois le mot de passe, et inscrivez le nouveau joueur seulement si les mots de passe coïncident. -
Implantez une gestion des mots de passe sécurisée: une mesure de sécurité souvent appliquée consiste à ne jamais stocker les mots de passe en clair dans la base de données. À la place, on stocke le haché (par exemple le SHA1) de la concaténation du mot de passe et d’une graine aléatoire propre à l’application.
Tout le calcul doit se faire côté server. En effet, premièrement la graine ne doit être connue que par le server, deuxièmement, si c’est le client qui fait le calcul, le haché devient effectivement le mot de passe à la place de l’original.
De cette façon, même l’administrateur ne peut pas connaître les mots de passe d’origine. En cas d’oubli du mot de passe, la seule solution est de ré-initialiser l’utilisateur. Un méprise de ce principe est à la base du fameux leak de 150M de mots de passe de Adobe en 2013 : http://zed0.co.uk/crossword/.
C’est en général une mauvaise idée de vouloir implanter ce système soi même dans une application : il y a beaucoup de pièges dans lesquels il est facile de tomber. Il vaut mieux utiliser les solutions déjà faites, prévues par le langage ou le framework. Voir par exemple la documentation de PHP sur le sujet ou le module bcrypt pour Node.js
-
Dans la page d’accueil, faites en sorte que les identifiants des joueurs soient auto-complétés. Voir https://developer.mozilla.org/docs/Web/HTML/Element/datalist.
-
Enrichissez les données sur les utilisateurs. Au minimum, cela pourrait se limiter au nom et prénom des joueurs. Vous pouvez pousser cela jusqu’à avoir un profil d’utilisateur complet de photos, etc.
-
Gérez correctement le fait qu’un utilisateur est allé hors ligne (événement
close
dereq
). Notifiez ses adversaires lorsqu’il est devenu hors ligne. -
L’API
EventSource
a l’avantage d’être simple à comprendre et à utiliser. Cependant, pour chaque échange asynchrone entre le client et le server, il a fallu créer une route montante (pour les envois client → server, via AJAX) et une route descendante (pour les envois server → client, via server push).Les web sockets, grâce à leur canal bidirectionnel, permettent de simplifier la logique et peuvent rendre l’application plus rapide. Récrivez la partie
/play
de votre application à l’aide d’une bibliothèque de web sockets, telle http://socket.io/. -
Permettez à un utilisateur de jouer plusieurs parties en même temps contre des adversaires différents.
-
L’utilisation de variables globales est pratique pour des simples applications mono-thread. Mais Node.js n’est pas uniquement destiné aux petites applications web : son noyau supporte du multi-processing et du load balancing, permettant de distribuer une application web sur plusieurs cores (voir le module Cluster de Node.js).
Dans un environnement multi-process, la mémoire globale n’est pas partagée avec les autres processus, il devient donc impossible d’utiliser les variables globales pour maintenir l’état. Il est alors nécessaire d’utiliser une base de données externe pour stocker l’état, avec en plus des garanties d’atomicité (transactions).
On pourrait, bien sûr, utiliser la base MySQL, comme cela est fait dans le TD en Silex. Cependant il est souvent plus simple et efficace d’utiliser un système NoSQL en mémoire vive, comme par exemple Redis. De plus le système pub/sub de Redis est parfaitement adapté au modèle à événements de Node.js et au server push.
Remplacez les variables globales par des objets stockés dans une base Redis. Il vous faudra lire et comprendre les manuels de Redis.
Pour installer et démarrer Redis dans C9, il faut exécuter dans la console
nada-nix install redis npm install redis redis-server --port 16379 --bind $IP
Lisez la documentation du module
node_redis
pour apprendre à vous servir de Redis dans Node.js.Le tutoriel sur l’utilisation de
EventSource
avec Node.js est une excellente introduction à l’utilisation du pub/sub de Redis dans une application asynchrone. -
Pourquoi ne pas mettre votre travail en ligne ? Aussi bien OpenShift que Heroku offrent un plan d’hébergement gratuit pour applications en Node.js (une liste plus longue d’hébergeurs supportant Node.js est disponible ici). C’est la vitrine idéale pour montrer votre travail à un futur employeur.
N’oubliez pas de mettre le code source sur GitHub… les employeurs adorent ça ! (Moi aussi, n’hésitez pas à m’envoyer un mail).