Netty (4/6) : que faire avec

[Laurent Caillette]

Nous avons vu les gros morceaux avec le ``ChannelPipeline`` et le
recyclage des tampons mémoire, mais il y a d'autres fonctionnalités
trop sympathiques pour ne pas en faire mention :

--- Netty peut utiliser directement OpenSSH pour accélérer le
chiffrement (et en récupérer les failles de sécurité).

--- Netty supporte une bibliothèque "Thread affinity" pour attacher un
fil d'exécution à un cœur du processeur, et limiter les risques
d'invalidation de cache.

--- Netty reconnaît les tuyaux nommées d'Unix ("named pipes") pour
communiquer avec des processus résidants sur la même machine. C'est
réputé beaucoup plus rapide que le passage par l'interface virtuelle
``localhost``.

--- Si on lui demande gentiment, Netty transfère des données
directement de la mémoire de masse vers la carte réseau en utilisant
l'accès mémoire direct ("Direct Memory Access"). Petit bémol, ça ne
peut pas fonctionner de pair avec du SSL.

--- De nombreuses classes de Netty sont pensées pour être utilisés
en-dehors de Netty. Par exemple le ``ByteBuf`` offre un tampon mémoire
beaucoup plus pratique que le ``java.nio.ByteBuffer``.

--- Netty peut appliquer un retour de pression ("backpressure") sur
une connexion TCP, c'est à dire que Netty n'envoie pas l'acquittement
TCP avant que le code applicatif ait eu le temps de consommer les
données reçues.

--- Netty fournit diverses briques pour supporter divers protocoles de
haut niveau. On pense bien sûr à HTTP et aux WebSockets, mais il y en
a pas mal d'autres.




== Que faire avec Netty

Maintenant que nous avons une idée de la profondeur technique du
produit et de sa versatilité, que pourrions-nous faire avec ? Voyons
quelques exemples à travers des produits existants.


=== Netty HTTP Client

"Netty HTTP Client"
https://github.com/timboudreau/netty-http-client
est, comme on peut l'imaginer, un client HTTP asynchrone. Il utilise
une interface programmatique fluide grâce à `Java 8`, et offre des
facilités pour écrire des assertions sur les résultats de requêtes,
pour ceux qui veulent tester le comportement d'un serveur HTTP.

=== LittleProxy

"LittleProxy"
https://github.com/adamfisk/LittleProxy
est un proxy HTTP embarquable en pur Java. On peut l'utiliser par
exemple pour tester le comportement d'un client HTTP, mais aussi pour
réécrire du contenu HTTP, ou pour des attaques de type
"homme-du-milieu" ("man-in-the-middle attacks") sur du contenu HTTPS.
Ce type d'attaque peut être utile pour examiner le fonctionnement de
programmes en phase de mise au point.


=== Ratpack

"Ratpack"
https://ratpack.io
est un socle technique pour écrire des applications Web embarquables
en tirant parti des fonctionnalités de Netty. Ratpack facilite
l'expression des comportements asynchrones, notamment grâce aux
lambdas de `Java 8`.


=== `Vert.x`

"`Vert.x`"
http://vertx.io
(prononcer "vertex") est un socle technique pour interconnecter des
briques programmatiques à travers divers protocoles réseau. `Vert.x`
oriente vers un modèle de programmation de type "acteurs" du fait de
la non-concurrence d'accès dans les ~``ChannelHandler``s. Même si
c'est assez limitatif, certains décrivent `Vert.x` comme une variante
polyglotte de `Node.js` avec de meilleurs performances.


=== Project Reactor

"Project Reactor"
https://projectreactor.io
inclut un connecteur Netty. Cette partie du code est encore à une
phase très précoce. La fonctionnalité-clé consiste à propager le
retour de pression à la connection TCP, c'est à dire que le client TCP
ne recevra pas d'accusé de réception tant qu'on n'aura pas la capacité
de traiter la donnée qu'il envoie. Ça nécessite que toute la chaîne de
traitement respecte le contrat définissant le retour de pression. Pour
plus de détails voir l'article précédent sur Project Reactor.


Dans le prochain épisode, nous étudierons le cas du remplacement d'un
existant par Netty.