Cela fait plusieurs fois qu’on me demande comment contribuer à SàT, le projet étant conséquent il n’est pas facile d’accès. Aussi voici un article d’introduction pour l’écriture d’un greffon pour le backend.

Il est très utile d’avoir lu l'article d’introduction sur l’architecture de SàT avant. L’intérêt de faire un greffon backend est qu’il fonctionnera avec tous les frontaux, autrement dit sur le web, sur le bureau, sur appareils portables (bientôt) voire en ligne de commande ou autre.

Nous allons faire un classique « Salut à Toi le monde ! » bien connu des développeurs.

avant de commencer, quelques remarques en vrac

Quelques remarques et notions utiles à savoir, ne vous inquiétez pas si vous ne comprenez pas tout du premier coup :

• SàT est actuellement en Python 2, le passage à Python 3 ayant été bloqué principalement par Twisted jusqu’ici. Mais les choses ont beaucoup avancé récemment, et Twisted fonctionne désormais partiellement avec Python 3, la partie XMPP est aussi en cours de portage, et le passage à Python 3 pourra être envisagé pour SàT 0.8 (après la version « grand public » donc).

• le style de code suit à peu près les conventions de la PEP 8, mais pas entièrement. En particulier les noms de méthodes utilisent le CamelCase pour rester cohérent avec le code de Twisted, et la limite des 80 caractères n’est pas respectée (il n’est pas impossible que cela change dans le futur), vous aurez plus de détails sur le wiki (notez bien la partie sur les docstrings).

• le backend de SàT est entièrement asynchrone, en utilisant Twisted. C’est probablement le plus difficile à appréhender pour un débutant, et vous pouvez commencer en regardant comment font les autres parties du code pour comprendre les grandes lignes. La chose la plus importante à retenir est qu’il ne faut jamais faire de code « bloquant », c’est-à-dire long à s’exécuter, car ça bloquera tout le backend. S’il est indispensable de bloquer pour une raison ou une autre (un module tiers à utiliser par exemple), vous devrez utiliser des processus séparés. La documentation sur le site mentionné est relativement fournie quand vous vous sentirez d’approfondir le domaine…

• la hierarchie du code (src) est actuellement comme suit:

  • bridge gère la communication avec les frontaux, c’est l'IPC (actuellement D-Bus mais d’autres options sont possibles)
  • core contient comme son nom l’indique le cœur du backend (le « Service » SàT, le client XMPP, les constantes, les exceptions spécifiques à SàT, la gestion des logs et de la traduction)
  • memory gère tout ce qui est conservation des données que ce soit en mémoire vive ou sur disque (via Sqlite pour le moment, mais d’autres options sont possibles)
  • plugins contient… les greffons, c’est à eux que l’on va s’intéresser par la suite
  • stdui contient les interfaces XMLUI de base (nous reparlerons de XMLUI plus bas)
  • test est le répertoire où sont comme vous vous en doutez les tests unitaires ou autre.
  • tmp est une hiérarchie que nous avons dû créer pour mettre du code temporaire destiné à être intégré par des projets tiers que nous utilisons, en particulier Wokkel à l’heure actuelle
  • tools est la hiérarchie un peu « fourre-tout » pour les choses utiles, en particulier XMLUI et les triggers dont nous reparlerons plus tard. La sous-hiérarchie « common » contient les modules utilisés/ables à la fois par le backend et les frontaux.
  • twisted enfin est uniquement utilisé pour l’intégration à Twisted
  • on parle souvent de profil (profile en anglais et dans le code) qui correspond à un compte XMPP. En mode mono-utilisateur (Primitivus ou Cagou par exemple), cela peut correspondre à plusieurs comptes d’un même utilisateur (par exemple j’ai un profil jabberfr et un autre libervia.org pour mes 2 comptes correspondant). En mode multi-utilisateur (avec Libervia par exemple), cela correspond à des comptes d’utilisateurs différents.
  • à la notion de « profile » s’ajoute celle de « profile_key ». C’est en fait en mot clef qui indique un profil à utiliser (vous les trouverez dans les constantes avec PROF_KEY_XXX). En particulier PROF_KEY_DEFAULT indique d’utiliser le profil par défaut, et PROF_KEY_NONE indique une valeur non renseignée qui provoquera une exception si elle est utilisée avec getClient (voir plus bas).

• dans les classes, on utilise souvent un attribut « host » (self.host la plupart du temps), qui correspond à l’instance du service SàT, et qui permet d'accéder à beaucoup de choses (le « bridge », la partie « memory », etc).

• dans les méthodes, vous verrez souvent les paramètres « client » ou « profile ». « profile » correspond au nom du profil dont on a parlé plus haut, et client à l’instance du client XMPP et donc à la session associée à ce profil. On passe du profil au client en faisant « host.getClient(profile) » et du client au profil en faisant « client.profile ». Avant « profile » était systématiquement utilisé et placé en dernier paramètre (avec une valeur par défaut de C.PROF_KEY_NONE qui indique une valeur non renseignée). Désormais il a été décidé de toujours utiliser client comme premier argument, et profile uniquement quand c’est nécessaire (à l’entrée ou la sortie du « bridge » par exemple), aussi le code passe petit à petit à la nouvelle convention, et vous pouvez voir les 2 cas.

• en début de fichier, il est souvent utile de faire ces imports :

  from sat.core.constants import Const as C
  

from sat.core.i18n import , D from sat.core.log import getLogger log = getLogger(name) from sat.core import exceptions

La première ligne permet d’accéder aux constantes, avec C pour que ça reste court et lisible. La seconde importe la fonction gettext «  » qui traduit le texte dans la langue locale au moment de son utilisation, et « D » qui indique qu’un texte est à traduire, mais que la traduction aura lieu plus tard dynamiquement (utile pour un menu par exemple, qu’on peut traduire différemment selon les profils). Les 2 suivantes instancient un loggeur qu’on peut utiliser assez classiquement avec log.[niveau](message), par exemple log.debug(u"mon message de debug") Enfin la dernière ligne permet d’utiliser les exceptions spécifiques à SàT, vous pouvez lire le code du module idoine pour plus d’infos.

Avec tout ça on a l’essentiel pour s’attaquer au code.

création du fichier et déclaration du plugin

La première chose à faire est de créer un fichier python dans le répertoire plugins et dont le nom commence par "plugin_". De tels fichiers sont automatiquement importés par le backend au démarrage, et à terme il devrait être possible de les mettre ailleurs (par exemple dans un dossier personnel) et de les télécharger et installer automatiquement. Vous constaterez que les greffons existant sont nommés avec leur type puis leur nom, et que ceux qui implémentent des XEPs prennent le nom de la XEP (par exemple plugin_xep_0045.py).

Nous allons maintenant déclarer le greffon, pour celà nous utilisons une variable (un dictionnaire) nommée PLUGIN_INFO et placée en début de fichier. Voici un exemple d’en-tête avec celui du greffon XEP-0045 (le salon de groupe MUC) :

PLUGIN_INFO = {
    "name": "XEP-0045 Plugin",
    "import_name": "XEP-0045",
    "type": "XEP",
    "protocols": ["XEP-0045"],
    "dependencies": [],
    "recommendations": [C.TEXT_CMDS],
    "main": "XEP_0045",
    "handler": "yes",
    "description": _(u"""Implementation of Multi-User Chat""")
}

voici les informations données:

• name : nom « lisible par un humain » donné au greffon
• import_name : nom court utilisé pour référencer ce greffon par ailleurs (depuis d’autres greffons par exemple) pour accéder à ce greffon par la suite, vous pourrez utiliser host.plugins[nom d'import], ainsi ici vous pourrez faire host.plugins["XEP-0045"]
• type : une information sur ce que qui est implémenté ; est-ce une XEP (type "XEP"), ou expérimentation (type "EXP") ? L’information n’est pas encore utilisée, mais elle devrait permettre de filtrer les greffons à l’avenir, quand ils seront téléchargeables depuis un dépôt. Les types courants ont leur constante de la forme PLUG_TYPE_*
• protocols : une liste de protocoles implémenté le cas échéant. Les XEP sont toujours référencées sous la forme XEP-0xxx avec « XEP » en majuscules.
• dependencies : autres greffons indispensables pour faire fonctionner celui-ci. C'est une liste de noms correspondant au « import_name » voulus. Ces greffons seront importés avant celui en cours, et s’ils ne sont pas disponibles l'import échouera
• recommendations : greffons non indispensable pour faire fonctionner celui en cours, mais qui apportent des améliorations si présents. Fonctionne de la même manière que dependencies sauf que l'import n’échouera pas si ces greffons ne sont pas disponibles
• main : classe principale du greffon, c’est cette classe qui sera instanciée à l'import et qu’on référencera en faisant host.plugins[XXX]
• handler : s’il vaut "yes", indique que le greffon va réagir à des requêtes XML particulières, toute autre valeur indique le contraire. Nous reparlerons des handlers plus tard
• description: texte décrivant ce que fait le greffon. Vous remarquerez la présence du _() qui est utilisé pour la traduction (gettext)

Pour notre greffon que nous allons mettre dans un fichier plugin_misc_salut_le_monde.py placé dans src/plugins, nous allons utiliser le code suivant :

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

from sat.core.constants import Const as C
from sat.core.i18n import _
from sat.core.log import getLogger
log = getLogger(__name__)

PLUGIN_INFO = {
    "name": u"Salut le monde",
    "import_name": "SALUT_MONDE",
    "type": C.PLUG_TYPE_MISC,
    "main": "Salut",
    "handler": "no",
    "description": _(u"""Plugin to learn basic concepts of SàT""")
}


class Salut(object):

    def __init__(self, host):
        log.info(_(u"Salut à Toi le monde !"))

C'est à peu près le greffon le plus simple que vous puissiez faire. En lançant SàT, vous devriez voir quelque chose similaire à ceci dans les logs :

2016-07-05 19:15:31+0200 [-] [sat.core.sat_main] importing plugin: Salut le monde
2016-07-05 19:15:31+0200 [-] [sat.plugins.plugin_misc_salut_le_monde] Salut à Toi le monde !

XMLUI

Bon tout ça c’est bien gentil, mais il serait quand même sympa d’avoir notre message sur les frontaux.

Comme vous le savez, SàT est multi-frontaux, autrement dit un message peut être affiché sur Libervia (interface web), sur Primitivus (interface console), (bientôt) sur Cagou (interface bureau/appareils portatifs) ou encore dans Emacs avec l’interface « Sententia ». Tous ces frontaux affichent les informations différemment : qui avec du texte directement, qui en HTML, qui via un cadriciel graphique, etc. Il serait ennuyant de devoir refaire l’affichage de l’interface pour chaque frontal, aussi nous avons créé un mini langage XML qui permet de décrire une interface de manière générique : XMLUI. C’est un langage descriptif simple et qui reste volontairement de haut niveau pour que le frontal affiche l’information comme il l’entend. On décrit des choses comme des textes, des JID, ou des listes.

XMLUI contient 2 classes « mères » principales : un widget (texte ou mot de passe par exemple), et un « container » (conteneur) qui dispose les widgets d’une certaine façon (verticalement, 2 par 2, en liste, etc). Vous pouvez lire le code gérant cela dans tools.xml_tools.

La création d’une interface se veut assez simple, et xml_tools contient des méthodes pour aider. Par exemple, l’interface suivante utilisée dans l'UI standard pour le gestionnaire de profils (dans stdui.ui_profile_manager) permet de demander un mot de passe si nécessaire :

form_ui = xml_tools.XMLUI("form", title=D_('Profile password for {}').format(profile), submit_id='')
form_ui.addPassword('profile_password', value='')
d = xml_tools.deferredUI(self.host, form_ui, chained=True)
d.addCallback(self._authenticateProfile, profile)
return {'xmlui': form_ui.toXml()}

Rien de bien compliqué. Quelques remarques sur ce code :

• on utilise D_ pour le titre, car il peut être traduit différemment d’un profil à l’autre
• une UI XML peut être soumise (c.-à-d. un résultat est envoyé par le frontal au backend, le mot de passe par exemple), et la méthode appelée dans le backend retourne un dictionnaire. Si celui-ci est vide, le dialogue est fini, s’il retourne une nouvelle interface avec la clef « xmlui », celle-ci sera affichée.
• pour soumettre une interface on peut soit enregistrer une callback via host.registerCallback (l’identifiant retourné sera utilisé avec submit_id au moment de la création de l'UI), soit utiliser une XMLUI « déferrée » comme ici, ce qui permet d’utiliser le mécanisme de Deferred de Twisted, submit_id doit dans ce cas être une chaîne vide.

Pour notre greffon de test, nous n’avons pas besoin de quelque chose nécessitant une réponse, nous pouvons utiliser la méthode xml_tools.note qui facilite les choses.

Pour utiliser une XMLUI, il y a plusieurs méthodes : création d’une callback via un menu par exemple, ou envoi d’un signal aux frontaux pour leur indiquer qu’il faut afficher l’interface, c’est ce que nous allons faire ici avec la méthode host.actionNew :

host.actionNew({"xmlui": xml_tools.note(u"Salut à Toi le monde !").toXml()}, profile=profile)

Remarquez le toXml() nécessaire pour convertir l'UI XML en texte utilisable à travers le bridge.

Nous avons presque notre greffon qui affiche un message, mais il y a encore un problème à régler : le greffon est importé au chargement du backend, un moment où les frontaux ne sont pas encore actifs, aussi nous ne pouvons pas afficher le message dans l'__init__, il serait envoyé dans le vide.

La solution est simple : nous allons afficher le message quand le profil est connecté. Dans ce cas, la méthode profileConnected, si elle existe, est appelé pour chaque greffon, avec pour seul argument le nom de profil.

Notre code devient donc :

#!/usr/bin/env python2
# -*- coding: utf-8 -*-

from sat.core.constants import Const as C
from sat.core.i18n import _
from sat.core.log import getLogger
log = getLogger(__name__)
from sat.tools import xml_tools

PLUGIN_INFO = {
    "name": u"Salut le monde",
    "import_name": "SALUT_MONDE",
    "type": C.PLUG_TYPE_MISC,
    "main": "Salut",
    "handler": "no",
    "description": _(u"""Plugin to learn basic concepts of SàT""")
}


class Salut(object):

    def __init__(self, host):
        self.host = host
        log.info(_(u"Salut à Toi le monde !"))

    def profileConnected(self, profile):
        msg = u"Salut à vous {} et le monde !".format(profile)
        self.host.actionNew({"xmlui": xml_tools.note(msg).toXml()}, profile=profile)

En lançant Primitivus, voici ce que l’on voit :

…et avec Libervia :

Vous aurez un message équivalent sur les autres frontaux.

À savoir également

Nous n’irons pas plus loin pour ce premier guide afin de ne pas être trop indigeste, mais il peut être utile d’expliquer succinctement d’autre éléments :

• il y a des paramètres que vous pouvez utiliser pour configurer votre greffon. Ils sont déclarés en XML, et il existe 2 types : « general » pour un paramètre global du backend (par exemple le port d’un serveur), et « individual » pour les paramètres qui changent avec les profils, ce qui est le cas le plus courant (par exemple le JID est un paramètre individuel).

• il y a un mécanisme de menus qui permettent d’associer une action (souvent un XMLUI) à un menu. Il y a plusieurs types de menus (regardez les constantes C.MENU_*) : C.MENU_GLOBAL sera le menu principal, tandis que C.MENU_JID_CONTEXT sera utilisé en cliquant sur un jid (un contact par exemple).

• si votre greffon gère une tâche longue quelconque (par exemple un transfert de fichier), il y a un mécanisme pour gérer les progressions, regardez les méthodes progress* pour avoir une idée de leur fonctionnement

• autre notion importante : la limite de sécurité. Il s’agit d’un simple entier qui indique si une méthode peut être utilisée en environnement restreint ou pas. Pour un frontal utilisé par un simple utilisateur ça n’est a priori pas utilisé, mais un frontal multi-utilisateur comme Libervia, ça permet de limiter ce qui peut être changé (le port d’un serveur ne doit pas être changé tandis que la syntaxe favorite peut l’être par exemple). Vous trouverez des explications sur le wiki.

• si votre greffon réagit au XML qui passe (ce qui est probablement — mais pas forcément — le cas si vous implémentez une XEP), il agit en « handler » et doit déclarer « "handler": "yes" » dans PLUGIN_INFO. Au moment de l'import, la méthode getHandler sera appelée et elle doit retourner l'instance à utiliser. Pour gérer « disco », votre classe doit implémenter wokkel.disco.IDisco et les méthodes getDiscoInfo et getDiscoItems, référez-vous au code des différents greffons pour bien comprendre.

• enfin les triggers permettent de modifier le comportement de SàT (du cœur ou d’un plugin), ce sont des méthodes qui sont appelées à certains endroits (d’autres projets parlent parfois de « hook »). Ils peuvent être utilisés par exemple pour modifier un message (le greffon OTR les utilise pour chiffrer le contenu). Il ne faut les utiliser que si nécessaire, car ils compliquent un peu la lecture du code.

Et bien entendu, vous pouvez toujours venir chercher de l’aide sur le salon MUC de SàT : sat@chat.jabberfr.org.

À vos claviers ! Et n’oubliez pas de nous faire signe si vous vous lancez dans quelque chose :)

P.-S. : les morceaux de codes ne sont pas mis en couleurs à l’heure actuelle, j’envisage de faire un greffon pour intégrer pygments, mais pour le moment la priorité est le développement de Cagou.