Une application de chat E4 avec VertX et les WebSockets

SampleChat

 

Le but de cet article est l’utilisation de l’implémentation des WebSocket [1] par VertX pour une application de chat.

Tout le code est disponible sur GitHub [2]

Dans un premier temps nous créerons un serveur Http pour nos websocket. Puis nous intégrerons VertX dans eclipse,et nous terminerons avec notre client  RCP E4.

 

I Un serveur Http pour nos Websockets

Nous créons un simple serveur http qui lorsqu’il recevra un message les publiera aux autres websocekts connectées.

public class WebSocketServer extends AbstractVerticle{
@Override
public void start(Future fut) {
vertx.createHttpServer().websocketHandler(new Handler() {
public void handle(final ServerWebSocket ws) {
final String id = ws.textHandlerID();
System.out.println("new connection from"+ ws.toString() + "id "+id);
vertx.eventBus().consumer("chat",message -> {
ws.writeFinalTextFrame((String) message.body());
});
ws.handler(new Handler() {
public void handle(Buffer data) {
// When our websocket receive data we publish it to our consumer
vertx.eventBus().publish("chat",data.toString());
}
});
ws.closeHandler(handler ->{
System.out.println("Close WS ");
});
}}
).requestHandler(new Handler() {
public void handle(HttpServerRequest req) {
req.response().end("Chat");
//Not usefull but it display chat on our browser
}
}).listen(8080);
}
}

Ce code crée un serveur http qui écoutera sur le port 8080.

Nous créons aussi un serveur de websocket qui a chaque connexion de websockets l’enregistrera sur l’eventBus de vertX.  Ainsi à chaque message reçu par nos websockets nous publierons le contenu de ce message à notre bus d’événements et ainsi écrira le contenu du message dans nos websockets.

 

Pour builder ce serveur il suffit de faire dans le répertoire fr.thibaultleouay.chat.server

mvn clean install
Pour le compiler puis :
java -jar target/fr.thibaultleouay.chat.server-0.0.1-SNAPSHOT-fat.jar

Vous pouvez vérifier que votre serveur est correctement lancé en vous connectant à localhost:8080 la page doit affiché chat

II Intégration de VertX dans eclipse

Pour intégrer VertX dans eclipse, sachant que VertX n’est pas disponible sur Orbit, nous mettrons en place notre propre update site. Il sera ainsi facile de gérer nos dépendances dans notre target platform. Je préfére personellement utilisé un fichier target pour définir mes targets platforms des différents projets.

 Création d’un nouveau plugin à partir de Jar existant

Nous créons un nouveau plugin à partir de jar existant en choissisant les jars nécessaires à vertx que nous avons téléchargé [3]

Création d’une feature

Nous créons une feature contenant notre plugin précédemment créer.

Création d’un update site

A partir de notre feature nous pouvons facilement créer un update site. Nous pouvons ainsi publier notre update site sur un serveur web pour pouvoir installer vertx dans notre eclipse. Par exemple http://thibaultleouay.github.io/VertX/ est mon update site.

 

III Création du client de chat RCP

 

Pour la création de cette application j’ai utilisé le template d’une application e4 avec des vues et des commandes prédéfini.


// We create our websocket on ws://localhost:8080
client.websocket(8080, "localhost", "", websocket -> {
websocket.handler(data -> {
//When we receive data from our websocket we update our widget though we should do it on the SWT thread
display.asyncExec(new Runnable() {
@Override
public void run() {
textViewer.setText(textViewer.getText()+ "\n"+data.toString("UTF-8"));
}
});
});

Lors de la création de la Part nous nous connectons à notre serveur de websockets. Quand nous recevrons des messages de notre websockets nous les mettrons à jour dans notre textviewer.

Quand nous cliquons sur le bouton send de notre application nous envoyons notre message à notre serveur de websocket.

 

[1] http://vertx.io/docs/vertx-core/java/#_websockets

[2] https://github.com/thibaultleouay/

[3] http://vertx.io/download

Publicités
Une application de chat E4 avec VertX et les WebSockets

Eclipse Performance

Un des reproches fait à Eclipse est sa lourdeur voici donc quelques astuces pour le rendre plus rapide :

  • Une JVM obsolète : Si vous utilisez une JVM ancienne mettez là à jour sachant qu’à chaque nouvelle version de JAVA des optimisations sont effectuées
  • Une version d’Eclipse obsolète :  La aussi des efforts sont fait à chaque release à propos de la performance d’eclipse, donc si vous pouvez télécharger la dernière version, si vous êtes obligés de rester en 3.x télécharger la 3.8.2 [1].
  • JVM optimisation : A vous de trouver suivant votre machine les arguments qui font en sorte que la JVM fonctionnera mieux, moins de stop of the world et co. Mais voici quelques arguments qui peuvent être intéressant :
    • -Xverify:none : Pour désactiver la vérification des Class au chargement de la JVM, cela peut apporter un gain d’environ 10/20%
    • -Xmx2048m ou moins si votre machine ne vous le permet pas afin de donner plus de mémoire à Eclipse que le default de la JVM
  • Des options Eclipse :

    • Désactiver : « File Icons Based on Content Analysis »  dans Window -> Preferences -> Appearance -> Label Decorations -> File Icons Based on Content Analysis
    • Ne pas afficher tous les problèmes de votre workspace en limitant le nombre à 100 par exemple, sachant qu’à 10000 problèmes dans votre workspace celui ci risque d’être inutilisable [2]
    • Si vous utilisez Eclipse 4.4>  vous pouvez démarrer Eclipse en désactivant le moteur CSS avec l’option -cssTheme none

[1] http://archive.eclipse.org/eclipse/downloads/drops/R-3.8.2-201301310800/

[2]https://bugs.eclipse.org/bugs/show_bug.cgi?id=349869

Eclipse Performance

Maven + Tycho + SureFire pour builder Eclipse

Eclipse + Maven/Tycho + Surefire
Eclipse + Maven/Tycho + Surefire

 

La platform eclipse est « buildé » en utilisant Maven/Tycho. Ainsi si vous souhaitez buildé seulement le projet platform.ui, il faudra utiliser la commande :

mvn clean install -Pbuild-individual-bundles

L’argument -Pbuild-individual-bundles indique que vous souhaitez seulement construire le projet platform.ui autrement tous les projets seront construit. C’est un profil maven qui a été défini dans les pom.xml parent (eclipse.platform.parent/pom.xml). Vous pouvez aussi lui indiquer de construire que pour une architecture donné avec l’argument -Dnative= »TargetPlatform »

De plus si vous êtes sur mac et que vous souhaitez lancer les tests lors de votre build, il vous faut modifier le pom.xml qui est à la racine de votre repertoire eclipse.platform.ui/tests afin de préciser à surefire de lancer l’application sur le premier thread graphique.


<configuration>
<argLine>-XstartOnFirstThread -Xmx2048m</argLine>
...
<configuration>

Maven + Tycho + SureFire pour builder Eclipse

Le démarrage d’Eclipse et le fichier eclipse.ini

eclipse.ini
eclipse.ini

Le démarrage d’Eclipse est contrôlé par le fichier eclipse.ini qui se trouve :  $ECLIPSE_HOME/eclipse.ini , si cette variable d’environnement n’existe pas il va utiliser celui qui se trouve dans votre répertoire d’installation Eclipse.

Ce fichier permet en particulier de donner des arguments à notre JVM e.g la taille du « heap » avec -Xmx1024m si nous rencontrons des problèmes de mémoires.

Cependant il y a quelques jours je ne comprenais pas pourquoi mon eclipse.ini n’était pas pris en compte, il ressemblait à ça :

-startup
../../../plugins/org.eclipse.equinox.launcher_1.2.0.v20110502.jar
--launcher.library
../../../plugins/org.eclipse.equinox.launcher.cocoa.macosx.x86_64_1.1.100.v20110502
-product org.eclipse.epp.package.jee.product
--launcher.defaultAction openFile
-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256m
--launcher.defaultAction
openFile
-vmargs
-Dosgi.requiredJavaVersion=1.5
-XX:MaxPermSize=256m
-Xms40m
-Xmx512m

Or après avoir relu le wiki[1] il y a trois points auxquels il faut faire attention.

  1. Chaque option et chaque argument pour une option doivent être sur leur propre ligne (C’était le problème de mon eclipse.ini)
  2. Toutes les lignes après -vmargs sont passés comme arguments à la jvm, ainsi toutes les options et arguments d’Eclipse doivent être défini avant
  3. L’utilisation de -vmargs depuis un prompt remplace tous arguments du fichier eclipse.ini sauf si –launcher.appendVmargs est spécifié soit dans le .ini soit dans la commande prompt

Ainsi pour que mon fichier eclipse.ini soit valide il aurait du ressembler à ça :


-startup
../../../plugins/org.eclipse.equinox.launcher_1.2.0.v20110502.jar
--launcher.library
../../../plugins/org.eclipse.equinox.launcher.cocoa.macosx.x86_64_1.1.100.v20110502
-product
org.eclipse.epp.package.jee.product
--launcher.defaultAction
openFile
-showsplash
org.eclipse.platform
--launcher.XXMaxPermSize
256m
--launcher.defaultAction
openFile
-vmargs
-Dosgi.requiredJavaVersion=1.5
-XX:MaxPermSize=256m
-Xms40m
-Xmx512m

HTH

[1] : https://wiki.eclipse.org/Eclipse.ini

Le démarrage d’Eclipse et le fichier eclipse.ini

SWT Tools : SLeak et SWT Spy

Lorsque que nous écrivons des interfaces graphiques avec SWT, il faut explicitement « disposer » les composants créés avec l’appel de la méthode dispose(). Or il se peut que nous oublions de libérer certains composants. Néanmoins il existe un outil qui peut nous permettre de vérifier que nous « disposons » correctement tous nos composants Cet outil est SLeak il est inclus dans les SWT Development Tools. Et nous pouvons l’utiliser pour nos applications RCP.  Pour cela la démarche à suivre est la suivante :

  1. Le télécharger, les différentes adresses  des P2 repositories  suivant les versions d’Eclipse sont indiqués à l’adresse suivante : https://www.eclipse.org/swt/updatesite.php
  2. Inclure le plug-in  dans notre launch configuration : org.eclipse.swt.tools
  3. Ajouter les options :
    org.eclipse.ui/debug=true
    org.eclipse.ui/trace/graphics=true

    Le plus simple pour cela reste à les sélectionner dans la tab tracing de notre launch configuration

    Sleak Launch configuration Tracing tab
    Sleak Launch configuration Tracing tab
  4. Ajouter la vue SLeak à notre perspective, par exemple :

    ​public class MainPerspective implements IPerspectiveFactory{
    public void createInitialLayout(final IPageLayout layout){
    IFolderLayout topRight = layout.createFolder("topRight", IPageLayout.RIGHT, 0.7f,layout.getEditorArea());
    IFolderLayout bottomRight = layout.createFolder("bottomRight", IPageLayout.BOTTOM, 0.5f, "topRight");
    topRight.addView("org.eclipse.swt.tools.views.SleakView");
    }}
  5. Nous pouvons ensuite lancer notre application et y trouver la vue SLeak. En cliquant sur snap puis diff nous pouvons voir les composants qui n’ont pas été disposé. La vue SWT Spy nous donne des informations SWT sur le composite en dessous de notre souris pour l’activer il faut ajouter la vue org.eclipse.swt.tools.views.SpyView.

    Les vues SLeak et SWT SPY
    Les vues SLeak et SWT SPY
  6. Il nous reste plus qu’à disposer les ressources que nous avons créé correctement.

PS : La source des SWT Tools est disponible ici : http://git.eclipse.org/c/platform/eclipse.platform.swt.git/tree/bundles/org.eclipse.swt.tools/

SWT Tools : SLeak et SWT Spy

Plug-in Selection Spy / Plug-in Menu Spy

Les outils plug-in selection spy et plug-in menu spy sont très utiles lors du développement d’application Eclipse RCP, ou de plug-in eclipse. Ils permettent de retrouver des informations importantes rapidement. Ces informations sont affichées avec les combinaisons de touches suivantes

  •  Plug-in Selection Spy : Alt + Shit + F1  / Alt +Shit + FN + 1 sur mac
  • Plug-in Menu Spy : Alt + Shit + F2 /   Alt +Shit + FN + 2 sur mac
Plug-in Selection Spy
Plug-in Selection Spy
Plug-in Menu Spy
Plug-in Menu Spy

Vous pouvez profiter ces fonctionnalités pour votre application RCP en incluant le plug-in org.eclipse.pde.runtime . Ce que vous pouvez faire simplement en le sélectionnant dans la launch configuraiton d’Eclipse.

Plug-in Selection Spy / Plug-in Menu Spy