goffi's blogxmpp%3Agoffi%40goffi.org%3F%3Bnode%3Durn%253Axmpp%253Amicroblog%253A02017-07-14T10:07:11ZÉmission radio sur la vie privée et Salut à Toid9d6fa7f-0f3b-4da0-9b7a-c9001b162dde2017-06-26T11:12:40Z2017-06-25T21:08:59Zgoffixmpp:goffi@goffi.org

Radio Prague vient de mettre en ligne une émission d'environ 10 min sur la vie privée où j'ai été interviewé pour parler de Salut à Toi.

Je suis vraiment content de l'émission qui est claire, bien expliquée, et pas trop technique . la journaliste a très bien compris le projet (ce qui n'est pas évident, il faut bien le reconnaître), et a fait du beau travail.

Vous pouvez l'écouter et la lire ici : http://www.radio.cz/fr/rubrique/panorama/la-disparition-de-la-vie-privee-nest-pas-inevitable

À écouter et faire circuler si le thème et/ou le projet vous intéressent. Comme indiqué dans lémission nous avons beaucoup de mal à nous faire connaître, aussi ce genre de chose nous aide bien.

Il y a beaucoup de choses qui ont avancé pour la version 0.7 à venir qui sera la première version dite « grand public » (comprendre, installable sans trop de difficultés et utilisable au jour le jour). J'espère trouver le temps de faire des articles pour expliquer les nouveautés comme un cadriciel (framework) web asynchrone/basé sur XMPP, la gestion des évenements ou encore des tickets (donc en décentralisé et basé sur XMPP). Si tout va bien une bêta est à attendre pendant l'été ou à la rentrée, ça sera l'occasion de s'organiser pour faciliter les contributions et mises en production.

À bientôt…

Salut à Toi sur bureau et Android (Cagou), état des lieux9c1eccb5-9ad3-47bf-9cbd-065640337e2f2017-07-13T19:37:38Z2017-02-22T22:12:02Zgoffixmpp:goffi@goffi.org

Salut à Vous !

Cela fait maintenant un peu plus d'un an que la campagne de financement participatif s'est achevée avec succès et que nous nous sommes engagés à développer une interface bureau/Android de « Salut à Toi », outil de communication multi-interfaces et multi-usages basé sur XMPP.

Il est temps de faire un petit état des lieux du développement. Vous trouverez en bas de cet article un lien vers une première version (pré-alpha) POUR TEST UNIQUEMENT.

Le contexte

Pour la petite histoire, nous entendions faire une campagne plus importante à l'origine quand nous avons décidé de faire un financement participatif. Mais suite à des discussions avec l'équipe d'Arizuka (plate-forme que nous avons choisie), nous avons largement réduit la somme demandée, ce qui s'est avéré judicieux puisque nous avons réussi la campagne : nous avons récolté 3 326,00 € sur les 3000 € demandés, soit 3 159,70 € après les frais.

Évidemment, cette somme est insuffisante pour vivre, aussi nous avons repris une activité salariée (j'en ai d'ailleurs parlé ici) et dû réduire le rythme de développement : je suis le seul développeur actif à l'heure actuelle (avec quelques contributions, notamment les accusés de réception et la authentification HTTP par XMPP par Chteufleur).

Ajouté aux choses annexes (gestion de l'association, écriture d'articles, projets liés, etc), ceci explique le temps de développement.

C'est aussi cette situation qui explique que nous avons réduit notre participation aux événements du Libre, ainsi vous ne nous avez pas vu au Fosdem cette année.

La plupart des contreparties promises aux soutiens ont été fournies (mais pas toutes, certaines n'ayant pas encore été réclamées). La somme reçue n'a pas encore été utilisée, sauf pour les frais fixes (serveurs, plate-forme de paiement des cotisations, banque).

Si ceci vous intéresse, vous trouverez les détails dans le compte rendu de la dernière assemblée générale extraordinaire de notre association.

Cagou

Comme déjà annoncé, la nouvelle interface de bureau et pour appareils mobiles (Android pour le moment) de SàT s'appelle « Cagou », un clin d'œil à l'outil Kivy que nous utilisons, et à cet oiseau emblématique de la Nouvelle-Calédonie, oiseau qui ne vole pas et qui aboie.

Développement

Cette partie est technique, vous pouvez passer directement à la suivante si cela ne vous intéresse pas.

Après une petite phase de prise en main de l’écosystème de Kivy, la première étape a été d'intégrer « Quick Frontend » (frontal rapide) qui est une base que nous utilisons, comme son nom l'indique, pour développer rapidement un frontal et factoriser le code (gestion du cache, de la liste des contacts (« roster » en XMPP), des widgets, etc.), puis d'intégrer le « bridge » (pont) qui est le nom que utilisons pour l'IPC qui permet la communication entre le « backend » (démon qui gère le cœur de SàT) et les frontaux.

Cette phase s'est relativement bien passée, elle a été accompagnée d'une réflexion sur l'architecture et l'interface utilisateur.

Une fois ceci à peu près utilisable, le port sur Android a pu commencer.

Les choses ont été un peu plus compliquées. La communauté Kivy a créé plusieurs outils pour développer sur cette plate-forme, dont python-for-android (outils de compilation et empaquetage) et Buildozer (outil multi-plateformes qui facilite l'utilisation du premier). La prise en main de ces outils demande quelques efforts, surtout pour un projet déjà en place (c'est nettement plus simple quand on commence directement avec Kivy et le port Android).

Il y a 2 « chaînes » de développement pour Android, l'ancienne et la nouvelle. Après des premiers tests non concluants avec la nouvelle, elle a été temporairement mise de côté pour l'ancienne le temps de développer les bases du port.

Les dépendances en Python pur s'importent facilement, mais dès que ça se complique un peu, il faut faire des recettes (« recipes ») pour indiquer à python-for-android comment faire la compilation. Heureusement, la plupart de celles nécessaires pour SàT (en particulier Twisted) étaient déjà disponibles, il a toutefois fallu les mettre à jour.

Une fois ces questions de dépendances et de chaîne de compilation réglées, et après le plaisir de voir un premier .apk apparaître (mais non fonctionnel). 2 autres gros problèmes se sont posés : D-Bus qui est le « bridge » principal n'est pas utilisable sur Android, et comment faire fonctionner backend et frontal en même temps ?

Étant novice pour le développement sur Android, j'ai dû lire beaucoup de documentation (qui ne manque pas heureusement) et après un premier essai avec un nouveau bridge « embedded » permettant d'avoir backend et frontal dans le même processus, c'est finalement l'écriture d'un bridge « pb » pour perspective broker, IPC de Twisted, qui s'est révélé être la meilleure solution. L'IPC d'Android est aussi une piste à explorer à l'avenir.

Pour lancer le backend, Kivy fourni des outils permettant de le lancer comme service Android, ce qui permet de le garder en arrière plan et de pouvoir gérer les messages et autres activités quand l'interface n'est pas visible pour l'utilisateur (ce qui signifie sur Android que l'interface est gelée jusqu'à ce qu'elle soit de nouveau sélectionnée par l'utilisateur).

Cette section est déjà bien longue, aussi je vous passe les autres difficultés (comme l'absence de widget gérant le HTML), parlons maintenant de l'interface.

L'interface

Cagou est donc utilisable sur bureau (GNU/Linux, mais probablement d'autres plates-formes également) et sur Android.

La version actuelle est une pré-alpha, l'.apk plus bas est fourni uniquement pour se faire une idée. Elle est très boguée, ne vérifie pas encore les certificats sur serveur, les enregistrements SRV ne sont pas pris en compte sur Android, etc. Elle est fournie pour d'une part montrer l'avancement, et d'autre part profiter des retours suffisamment tôt dans le développement pour prendre une bonne direction.

concepts de base

L'interface de Cagou est inspirée de celle de l'excellent Blender. En particulier la sélection de widget et la possibilité de faire des divisions à volonté en faisant glisser les bords du widget. Les grosses barres actuelle devraient disparaître à terme pour un bouton plus discret, probablement là encore inspiré de Blender. L'idée est qu'un utilisateur novice puisse changer de widget intuitivement, et qu'un utilisateur avancé puisse utiliser cette fonctionnalité.

séparation de widdgets

La liste des contacts n'est pas l'élément principal de l'interface, elle peut être affichée si souhaité, mais n'est pas nécessaire à l'utilisation de Cagou.

Le menu en haut, pour le moment tout le temps visible, ne devrait être disponible que sur bureau, sur Android le bouton menu ou un bouton flottant vont probablement le remplacer d'ici la sortie stable.

Si vous avez des notifications, elles apparaissent pendant quelques secondes en haut, mais vous pouvez le lire en prenant votre temps en caressant la tête du cagou qui apparaît alors en haut à gauche.

une notification dans Cagou

Dans le cas d'événements nécessitant votre intervention (par exemple une autorisation d'accès via XMPP sur un site), un cagou apparaîtra sur la droite, et le dialogue n'apparaîtra qu'après l'avoir touché. L'idée est de ne jamais avoir de fenêtre modale (type « pop-up ») qui surgit et vole le focus alors que vous faites autre chose. Ces dernières n'apparaissent que suite à une action de l'utilisateur.

Dans le cas d'Android, il est possible que ces notifications soient remplacées par le système de notification natif, mais le choix n'est pas arrêté puisque l'historique des messages ne serait alors plus disponible.

Pour changer de mode (de widget), il suffit de cliquer sur le bouton en haut à gauche du widget actuel. Il n'y a actuellement que 4 widgets : le sélecteur qui affiche tous ceux disponibles, la configuration, la liste de contacts, et le chat. D'autres sont à venir, en particulier le blogage.

sélection du widget/mode

À l’intérieur d'un widget (uniquement pour la messagerie instantanée pour l'instant), il est possible de faire un mouvement de glisser horizontal pour passer d'une conversation ouverte à une autre.

exemple d'un glissé de widget dans Cagou

Pour le moment ça n'est pas évident à utiliser la première fois (il faut faire un mouvement vif), il y a des petits réglages à prévoir.

Comme pour le reste de SàT, Cagou est prévu dès l'origine pour fonctionner avec des greffons et être facilement extensible. Tous les widgets et système d'envoi de fichiers (voir plus bas) sont des greffons.

messagerie instantanée (chat)

Comme nous voulons une interface utilisable sur petits écrans, simple, mais qui ne sacrifie pas les fonctionnalités, il faut trouver un compromis entre les informations affichées/ables à l'écran et les éléments/boutons permettant des actions. Trop d’éléments compliquent l'interface et prennent de l'espace, mais trop peu rendent les actions difficiles d'accès.

La disposition choisie actuellement (qui peut évoluer) consiste en un en-tête avec une barre de saisie et un bouton (en plus du sélecteur de widgets), le corps avec les messages, et une barre de saisie avec un bouton également.

Pour discuter avec un ou des contact(s), entrez des lettres faisant partie de son nom (n'importe où dans le nom). Pour le moment uniquement les identifiants (« jid ») et les conversations déjà ouvertes sont cherchés, mais à terme la recherche se fera également dans les noms, surnoms et dans les marque-pages.

sélection d'un contact pour une discussion instantanée

Cagou détecte si vous voulez parler à une personne seule ou dans un salon de discussion, et s'adapte en conséquence.

Le chiffrement de bout en bout est de la partie, mais uniquement avec OTR (v2) à l'heure actuelle. Il est prévu d'intégrer OX (OpenPGP moderne) et OMEMO, mais il n'est pas certains que ça sera disponible pour la prochaine version (ça sera peut-être pour la 0.8). Pour l'activer, il suffit de cliquer sur le cadenas, ce dernier sera fermé si la conversation est chiffrée, et aura un point d'interrogation si votre correspondant n'est pas authentifié.

Passons directement à la barre de saisie. Vous trouverez sur la droite un bouton « + » qui sert pour le moment à ouvrir le dialogue d'envoi d'élément.

Ce dialogue comporte 2 boutons en haut, qui permettent de choisir si vous voulez téléverser votre fichier ou l'envoyer directement à un correspondant en pair à pair. Un texte en dessous indique en langage clair où votre fichier transitera, et si le chiffrement intervient (à l'heure actuelle tout est en clair pour les fichiers).

Le message texte est important pour que l'utilisateur comprenne bien où vont ses données, c'est une indication que l'on va sûrement placer à divers endroits stratégiques.

dialogue d'envoi de fichier sous Android

Les boutons en dessous sont les types d'envoi. Sur bureau il n'est actuellement possible que d'envoyer un fichier de votre arborescence, mais sur Android il est possible également d'envoyer une photo de votre galerie, d'en prendre une nouvelle ou de faire une vidéo, et d'enregistrer un message audio.

Voici à quoi ressemble l'enregistrement de messages :

enregistrement d'un message audio

et autour

En plus du travail sur Cagou lui-même, d'autres travaux ont été effectué.

Désormais indispensable avec l'utilisation sur appareils portables, la copie carbone a été implémentée. La gestion des archives sur le serveur est elle implémentée depuis longtemps pour le blogage, mais pas encore pour les messages, ça sera fait d'ici la sortie de la version stable.

La gestion des petits fichiers binaires (« BoB » pour « Bits of Binary ») est désormais disponible, son implémentation a notamment été motivée parce qu'ils sont utilisés par Movim.

Comme indiqué plus haut, les accusés de réception et l'authentification HTTP ont été implémentés par Chteufleur.

Depuis la 0.6.1 la gestion des messages a été améliorée, préparant notamment le terrain pour des fonctionnalités comme la correction du dernier message, prévue pour la version stable.

Plus récemment la gestion des composants (pour préparer les passerelles) et des blogs statiques sont également arrivés, mais nous en parlerons peut-être une autre fois.

soutien

C'est un appel que nous faisons souvent mais qui n'est pas toujours entendu, de l'aide serait grandement appréciée.

Ce peut être aussi simple que venir discuter avec nous (notre salon est à sat@chat.jabberfr.org, disponible en cliquant sur ce lien).

Si vous avez de quoi, une contribution financière serait bien sûr utile, nous avons récemment ouvert un compte sur Liberapay, suite a discussion résumée dans le compte rendu de l'A.G. lié plus haut. Notre objectif est de réussir dans un premier temps à travailler un jour par semaine sur SàT et de compenser la perte de salaire par des dons.

Vous pouvez aussi adhérer à notre association, toutes les infos sont par ici. Vous choisissez le montant de la cotisation (entre 0 et 100 €).

Et bien sûr des contributions, en particulier du développement, mais aussi des traductions, du graphisme, du thème CSS, de l'administration des serveurs. La plupart du développement est fait en Python, et c'est participer à un outil que vous utiliserez potentiellement tous les jours.

Parler de notre association et projet autour de vous est toujours utile.

Je crois que l'essentiel est dit pour cette fois, j’essaierai de tenir informé avec des billets moins longs les prochaines fois.

Ah, et le lien vers la pré-alpha actuelle (encore une fois: POUR TEST UNIQUEMENT): https://www.goffi.org/public/Cagou-0.1-debug.apk

Premiers jappements de Cagouddc8d18f-bae7-4929-8af8-fe51b8d803232017-07-13T22:44:53Z2016-09-14T09:05:48Zgoffixmpp:goffi@goffi.org

Salut à vous,

Cagou commençant à prendre sérieusement forme, il est temps de faire un billet sur l'avancement.

Avant le début du développement de l'interface elle-même, des changements nécessaires ont été faits en particulier sur la gestion des messages. Outre la gestion des langues dont j'ai parlé dans des précédents billets, le plus important est que nous pouvons désormais changer l'état d'un message après réception, ou y faire référence. Ceci permet d'implémenter des fonctionnalités comme les accusés de réception, ce qui a été fait par une contribution de Chteufleur (merci :)). D'autres fonctionnalités qui attendaient comme la correction du dernier message vont bientôt pouvoir suivre.

Il était nécessaire de faire ce travail avant d'implémenter la messagerie instantanée sur Cagou, pour pouvoir partir sur de bonnes bases.

Ensuite il a fallu intégrer l'interface sous Kivy à SàT, et en particulier D-Bus et QuickFrontend, notre modèle pour faire des frontaux en Python.

Tout ceci s'est relativement bien passé, et voici une petite vidéo pour vous mettre en appétit :

Quelques explications maintenant.

Comme vous le voyez, l'interface peut-être divisée facilement. Cette idée est inspirée de l'excellente interface de Blender, et permettra de s'adapter facilement à un petit ou grand écran en choisissant le nombre de widgets et leur disposition.
Au lieu d'être un logiciel discret qu'on utilise uniquement quand on veut répondre à quelqu'un, Cagou est une interface qui s'utilise principalement en plein écran, avec une disposition adaptée à la situation et les outils importants directement visibles (si la taille de l'écran le permet).

Autre point important, la liste de contacts n'est pas l'élément central comme c'est souvent le cas dans les logiciels de messagerie. Vous pouvez y accéder en sélectionnant le widget, voire la mettre sur le côté pour reproduire le comportement traditionnel, mais elle n'est pas affichée par défaut et n'est pas indispensable.

sélection de widget

Tous les widgets sont des greffons, a terme il devrait être possible d'en télécharger, ou de changer complément le fonctionnement d'un widget de base. Comme effet de bord, et surtout grâce au travail de l'équipe derrière Kivy, Cagou sera une plate-forme qui permettra d'échanger facilement des scripts Python sur Android (reste à voir comment on va gérer les permissions).

En ce qui concerne les notifications, le fonctionnement va être différent sur bureau et sur les plates-formes qui ont déjà un système de notification (comme Android). Dans ce dernier cas, le système de la plate-forme va être utilisé.
Sur bureau, un en-tête spécifique est utilisé. 2 icônes de Cagou (merci à Muchoslava pour ses contributions) peuvent apparaître : une à gauche pour les notes (c.-à-.d les messages court qui ne s'affichent que quelques secondes), et une à droite pour les notifications plus importantes, nécessitant l'action de l'utilisateur.
Un clique sur l’icône de gauche permet d'afficher les 10 dernières notes, et un sur l’icône de droite affiche la notification importante suivante.

Ceci a été pensé pour éviter les popups, ces dernières ne sont affichées que suite à une action de l'utilisateur, et n’apparaissent pas d'elles même si un quelconque événement les déclenche.

exemple de notification

Les menus ont également été implémentés, ils apparaissent en haut sur bureau. Sur petits écrans (téléphones), ils ne seront sûrement visibles que suite à l'appui de la touche idoine.

Grâce au fonctionnement de Salut à Toi, ceux-ci permettent déjà de faire des actions de base comme ajouter ou modifier un contact et avancées comme piloter son serveur.

Enfin le lancement d'une conversation peut se faire de plusieurs manières. On peut en commencer une en cliquant sur un contact dans le widget « liste de contacts », ou en tapant son jid dans un widget « chat » (il devrait rapidement être possible de taper quelques lettres pour avoir les suggestions). Les conversations ne se ferment pas quand on change de widget, on peut accéder aux conversations en cours en faisant passer son doigt (ou sa souris pendant un clique) rapidement vers la droite ou la gauche, cf. la vidéo ci-dessous. Il sera bientôt possible de les fermer via un menu dédié.

Voilà l'état des lieux actuel. Il y a déjà eu beaucoup de travail, et l'interface commence à être vraiment utilisable. Côté bureau le plus gros est fait, il s'agit maintenant d'adapter l'interface aux fonctionnalités (afficher l'accusé de réception par exemple), et à faire de nouveaux widgets. Un gros morceau reste toutefois l'affichage du contenu HTML, vu que ça n'est pas géré de base par Kivy (mais il y a différentes solutions possibles).

En ce qui concerne Android, il va y avoir une partie qui risque d'être un peu difficile pour faire le port, mais je ne m'inquiète pas plus que ça.

J'envisage également de faire un port sur Ubuntu Touch, j'ai commandé à cette fin une tablette d'occasion qui devrait me permettre de l'installer (ce n'est pas une promesse, juste une éventualité).

Ah et bien sûr, Cagou va profiter des fonctionnalités de SàT, y compris le chiffrement de bout en bout (OTR pour le moment, mais OpenPGP est envisagé pour la 0.7, et peut-être OMEMO également).

Petite note pour les programmeurs : une fois la prise en main passée (qui n'est pas très difficile), j'apprécie beaucoup travailler avec Kivy, c'est souple, agréable à utiliser et ça fonctionne jusqu'ici très bien, félicitation aux équipes derrière.

Je conclus sur une bouteille à la mer : c'est un travail absolument énorme de travailler sur SàT, et à l'heure actuelle je suis pratiquement seul dessus, et en plus de mon emploi salarié. Le projet avance toujours à bon train, mais j'ai besoin d'aide. La base de code est importante, mais il n'est pas insurmontable de s'y mettre : Chteufleur mentionné plus haut a pu rapidement écrire des greffons et a fait les implémentations des XEP-0070 et XEP-0184.

Il est aussi possible de contribuer en dehors du code : empaquetage pour des distributions, tests, graphismes, traductions, installation de serveurs, etc. Contribuer à une bibliothèque utilisée par SàT (comme l'implémentation de XMPP dans Twisted ou Kivy) est également très utile.

Au passage, je rappelle à ceux qui ont participé à la campagne de financement, qu'ils peuvent nous contacter sur « contact chez salut-a-toi point org » pour réclamer leur contrepartie, ou la demander plus tard s'ils préfèrent.

À très bientôt pour la suite :)

Salut à Toi 0.6.108e8ea05-5d88-4a6f-a13b-eb6e548d65de2016-07-14T20:34:17Z2016-07-13T01:36:30Zgoffixmpp:goffi@goffi.org

Salut à tous,

la version 0.6.1 de Salut à Toi vient de sortir, et elle est conséquente malgré son numéro de version mineur. La prochaine version — qui est déjà bien entamée — sera la version « grand public » que nous annonçons depuis des années, autrement dit une version que nous voulons suffisamment stable pour être utilisée au quotidien, et suffisamment facile à installer pour être disponible pour un large public.

Vous pouvez toujours vous référer au journal des modifications (changelog) ou au dépôt pour avoir le détail, mais voici quelques unes des nouveautés et corrections principales :

  • plugin d'import extensible avec « importeurs » pour Dotclear et DokuWiki. Notez bien que grâce à l’utilisation des standards, ça peut vous être utile même si vous n’utilisez pas SàT pour afficher votre blog (c’est compatible avec Movim par exemple)
  • en plus de l'import Dotclear, la syntaxe wiki Dotclear est également disponible avec SàT désormais, elle vient s’ajouter à Markdown et XHTML.
  • inscription automatique à un flux PubSub pour les nouveaux comptes, ce qui évite d'arriver sur une page vide
  • MAM (XEP-0313) est implémentée pour PubSub, ce qui permet de remonter dans les articles et de faire des recherches de manière beaucoup plus souple et puissante. Notez que MAM n’est pas encore disponible pour la messagerie instantanée, ce sera le cas pour la 0.7
  • meilleure détection de la version du dépôt utilisée
  • jp (l’interface en ligne de commande) a désormais une option --output qui permet de spécifier le format de sortie (par exemple du JSON ce qui permet de facilement parser le résultat avec une autre commande). C’est encore peu utilisé mais la base est là.
  • jp : nouvelles commandes pour importer un blog (import), (ré-)éditer un nouveau/ancien billet (edit) ou voir l’aperçu mis à jour en temps réel (preview). Pour plus d’infos, référez-vous au billet d’explication qui montre comment publier sur votre blog avec Vim ou autre
  • jp : des nouvelles commandes également pour la gestion du roster, qui permettent de l’afficher (get), d’avoir des statistiques (stats) ou de le nettoyer (purge)
  • jp : la commande « message » a été déplacée vers « message send » par cohérence avec les autres commandes, et parce qu’un « message get » est à prévoir
  • jp : les codes de retour utilisent maintenant des constantes, afin qu’ils soient plus utiles
  • Primitivus (interface console) : détection d’un « coller » (une validation est nécessaire dans ce cas, ce qui évite l’envoi accidentel d’un mauvais message comme un mot de passe copié peu avant) et gestion du mode « bracketed paste »
  • Libervia (interface web) : une nouvelle option « allow_registration » permet de désactiver la création de nouveaux comptes, pratique si vous êtes seul sur votre instance, ou si vous créez les comptes par vos propres moyens
  • Libervia : affichage d’un message avec compteur en cas de perte de connexion avec le serveur
  • Libervia : utilisation d’une nouvelle favicon avec un compteur de notifications visible
  • Libervia : correction de la connexion avec un compte (jid) extérieur. Cette fonctionnalité très demandée nous avait causé de gros problèmes à la sortie de la 0.6.0, ils devraient être désormais réglés.
  • Libervia : il est maintenant possible de rediriger les pages ou d'intégrer un répertoire local dans Libervia. C’est ce qui permet d’afficher directement le blog au lieu de la page d’enregistrement sur www.goffi.org.
  • Libervia : gestion des chaînes TLS (Let's Encrypt, si tu nous lis…)
  • Libervia (blog): gestion des étiquettes (tags), y compris la recherche

Voilà pour un aperçu, et c’est loin de couvrir toutes les améliorations de la 0.6.1.

En lisant ceci vous aurez peut-être une petite idée de la quantité de travail nécessaire pour faire avancer un projet comme celui-ci, sachant que nous ne sommes que 2 (et que pour la 0.7 je suis pratiquement tout seul). Aussi si vous voulez participer à un projet éthique et qui refuse de céder aux sirènes des grosses entreprises privatristes, contactez-nous (contact at salut-a-toi point org) ! Rejoignez-nous sur notre salon MUC ! Venez nous aider, on en a grand besoin !

La version 0.6.1 n’est pas parfaite, elle a quelques problèmes (connus ou non), mais nous avons préféré sortir cette version qui malgré tout fonctionne, pour nous concentrer sur la 0.7, qui sera la première version « grand public », annoncée depuis des années.

La version 0.7 passera par une phase de bêta test, et devrait apporter en particulier :

  • un ré-usinage des messages qui permettra d’implémenter de nombreuses extensions bloquées jusqu’ici, comme la correction du dernier message, ou les archives côté serveur (MAM). Cette partie est déjà finie

  • Cagou, l'interface bureau/appareils portatifs que nous avons promis suite au succès de notre campagne de financement participatif. Le développement est bien avancé, bientôt un billet sur le sujet

  • des passerelles de messagerie et de blog. Cela fait longtemps qu'on parle d'en faire, les premières devraient voir le jour dès que Cagou est disponible

En dehors de ça, il est probable que nous implémentions de nouveaux systèmes de chiffrement de bout en bout, en plus d'OTR qui est déjà disponible. OpenPGP est visé en particulier, ainsi qu'OMEMO.

Les grosses fonctionnalités comme l’organisation d’événements ou les calendriers partagés sont plutôt envisagées pour la version suivante.

Ah, et la nouvelle version est disponible comme d’habitude sur le FTP, sur PyPi ou directement depuis le dépôt.

guide : écrire un greffon pour SàT309142d2-beee-4f9e-9b48-b5211374dc582017-07-07T08:06:33Z2016-07-06T21:12:50Zgoffixmpp:goffi@goffi.org

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 :

résultat avec Primitivus

…et avec Libervia :

résultat 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.

De la place de la langue dans nos communicationsa71c01a2-f95c-4017-8cc7-eb962d64db002017-07-13T19:42:04Z2016-06-22T20:03:41Zgoffixmpp:goffi@goffi.org

Une des belles choses qu’Internet a apporté — ou tenté d’apporter parce que certains y mettent des barrières virtuelles [1] — est la relative abolition des frontières. Il est devenu facile de communiquer avec des gens de tous pays ou presque, de partager des œuvres, de s’informer, ou encore de travailler ensemble à des milliers de kilomètres de distance. Le moyen de communication le plus utilisé est sans aucun doute l’écrit.

Quand on écrit quelque chose et qu’on le diffuse sur Internet, que ce soit un article sur un blog, de la documentation pour un logiciel, une information à communiquer, ou tout autre document public, on souhaite souvent que sa diffusion soit la plus large possible. Or à notre époque si on veut être lu, il faut adopter la culture de l’internet, publier sur les sites/réseaux en vue de l’internet et utiliser la langue de l’internet.

— la langue de l’internet ? Quelle langue de l’internet ?

— l’anglais bien sûr ! si tu veux être lu, point de salut, c’est l’anglais ou l’indifférence

— mais ceux qui ne parlent pas anglais ?

— pas anglais ? Allons allons, un peu de sérieux, tout le monde parle anglais de nos jours !

Oserais-je avancer le contraire ? Après tout il y a une commodité certaine à utiliser une langue commune, voire n’ayons pas peur des mots, universelle. Pourquoi s’embêter à traduire les choses, à rédiger plusieurs fois, à prendre du temps quand tout doit aller tellement vite ?

Eh bien osons ! Non tout le monde ne parle pas anglais, et osons même plus : il y a énormément de gens qui ne le parlent pas, ou très mal. Oui bien sûr il y a ce couple d’une autre époque, trop vieux pour avoir appris, et cet autre là, plus jeune, mais issu d’un lieu et d’un temps où l’anglais n’était pas bien vu. Ah mais attendez ! Il y aussi ce jeune là, qui n’a jamais trop bougé de sa campagne, et cet autre là qui vient d’un pays où il est peu courant de le parler, celui-là qui vient pourtant d’une grande capitale d’Europe (ce n’est pas la langue de l’Europe ?), et cet autre encore…

Même pour ceux qui le parlent, pour ceux-là, tout n’est pas si simple. Oui bien sûr il y a les « natifs », ceux dont c’est la langue maternelle, et puis il y a ceux qui ont eu les moyens de voyager, la chance d’avoir une éducation ou qui sont simplement doués pour ça. Mais même de ceux-là, combien sont capables de s’exprimer avec autant d’aisance, avec autant de nuances que dans leur langue maternelle ?

Oh, et bien entendu je fais l’impasse sur la culture que la langue véhicule, sur l’influence exacerbée des auteurs anglophones, et sur l’isolation des autres.

Accepter la domination de quelques langues ce n’est pas seulement refuser l’accessibilité ; c’est tuer la diversité et avant tout formater notre façon de penser.

Parlons maintenant un peu plus technique

Quand on écrit un message dans un système de discussion, il est possible de l'« étiqueter » avec des informations (les métadonnées) et en particulier de préciser la langue dans lequel il est rédigé. Cette information est disponible naturellement avec le protocole XMPP, et il est même prévu d’envoyer un message en plusieurs langues simultanément.

Cette propriété est à mon sens essentielle et complètement sous-exploitée dans les logiciels actuels. Pourtant, elle peut être extrêmement utile : un salon de discussion peut être multilingue (les gens n’ayant que les messages dans une langue qu’ils comprennent), un système de conversation (contact d’association, support technique, demande quelconque) peut être dirigé directement vers une personne parlant la langue idoine, une traduction peut être demandée pour un message important, un programme électronique (ou « bot ») peut envoyer des messages dans plusieurs langues à la fois, les règles typographiques peuvent être adaptées, etc.

Ces informations sont désormais utilisées dans « Salut à Toi ». Un greffon expérimental permet même de détecter la langue utilisée automatiquement [2] si celle-ci n’est pas explicitement spécifiée ; ainsi dans un salon multilingue, il est possible de passer du français à l’anglais sans devoir le préciser manuellement à chaque fois.

Ci-dessous une petite animation de la détection d’un texte en plusieurs langues, puis de l’utilisation d’un filtre pour n’afficher que l’une d’entre elles.

filtrage par langue dans Primitivus

Ce n’est qu’un premier pas, il y a beaucoup de choses envisageables pour permettre aux gens de s’exprimer dans la langue qu’ils maîtrisent le mieux, et bien sûr en dehors de la messagerie instantanée également (pour le blog par exemple).

Ah, et puisque vous le demandez, non SàT n’utilisera pas de drapeaux pour les langues, ceux souvent utilisés à cette fin étant des symboles de pays et non de langues.


[1]grand « firewall » de Chine, vidéo ou autre visible uniquement depuis certains pays, blocage de sites, etc

[2]greffon basé sur langid.py, les résultats sont corrects mais pas parfaits, il y a toutefois des améliorations envisageables

SàT: quelques nouvelles en vrac0572f54e-2641-4388-ae6e-cd6cbf1e0b792017-07-13T22:47:31Z2016-04-27T00:04:10Zgoffixmpp:goffi@goffi.org

Salut à vous,

j'ai assez peu de temps devant moi, alors je vais faire bref pour les quelques nouvelles sur notre avancement.

Déjà je voulais annoncer que nous ne sommes plus à plein temps sur SàT, Souliane et moi avons repris un travail salarié. Le rythme de développement s'en retrouve bien sûr réduit, mais reste relativement soutenu.

Le développement sur Cagou, notre prochaine interface bureau/appareils portables promise suite à notre financement participatif, est d'ailleurs en cours, il est possible de se connecter depuis, et il y a une gestion basique des widgets.

Voici une petite vidéo avec les premières images. La gestion des widgets est inspirée de l'excellente interface de Blender : l'idée est d'avoir à la base un seul widget que l'on peut changer en cliquant sur une icône (un widget pouvant être une conversation, un fil de blogs, des fichiers en partage, la liste de contacts, etc), et de pouvoir séparer l'écran en faisant glisser une barre. Ne faites pas attention à l’aspect graphique qui va changer (j'ai pris une barre du thème par défaut de Kivy pour le développement, mais ça va changer par la suite).

Mais ça n'est pas tout ! Un autre frontal est en cours de développement, destiné à Emacs le bien connu système d'expl éditeur de texte. Il répond au doux nom de « Sententia », et c'est Xavier Maillard qui s'est lancé dedans, et vous pouvez suivre son avancement (ou lui filer un coup de pouce *clin d'œil* *clin d'œil*) sur http://git.maillard.im/xma/sententia.
Une petite mise en appétit :

Première image de sententia

Il y a pas mal de développements en cours, mais je commence à fatiguer, alors je détaillerai une autre fois.

Enfin, pour ceux qui sont dans cette zone, nous serons Souliane et moi à la « Linuxwochen » ce samedi à Vienne (Autriche) pour présenter SàT : https://cfp.linuxwochen.at/de/LWW16/public/events/398.

À bientôt !

Parlons XMPP - épisode 10 - copie de fichiers et Jingle (suite)4f90a662-10ea-4b76-8025-d4b512d61e312016-03-31T15:49:17Z2016-03-31T13:41:12Zgoffixmpp:goffi@goffi.org

pour lire les épisodes précédents, suivez l'étiquette correspondante

Maintenant que nous avons vu la copie de fichiers « classique » et ses défauts, abordons une technologie qui a fait beaucoup parler d'elle — et à raison — quand elle est arrivée : Jingle.

Pour la petite histoire, Jingle est une technologie qui résulte d'un effort commun entre des membres de la XSF et une équipe chez Google qui travaillait sur un protocole de voix sur IP (VoIP). La page Wikipédia retrace succinctement l'historique. La technologie Web « WebRTC » hérite et s'inspire de ce travail.

Jingle est souvent considéré à tort comme une technologie dédiée à la visioconférence. En réalité, c'est une technologie qui permet d'établir une session Pair à Pair (P2P) et de la contrôler de manière très souple. Elle a bien été pensée à l'origine pour la visioconférence, et la XEP-0167 s'appuie dessus à cet effet, mais toute application utilisant des connexions directes (et il y en a beaucoup !) peuvent profiter de Jingle : travail collaboratif, tableau blanc, jeux, chiffrement de bout en bout (en évitant ainsi le serveur), partage d'écran, etc. Nous allons nous intéresser plus particulièrement à une de ces applications : le transfert de fichiers.

Jingle fait une séparation claire entre l'application (ici le transfert de fichier), les transports (nous allons retrouver les connexions « in-band » et « SOCKS5 » mentionnées dans le dernier article), et la gestion de session.
Les applications et les transports sont décrits dans des extensions à part : la copie de fichiers est décrite dans la XEP-0234 « Jingle File Transfert ». Vous noterez qu'elle est toujours au statut « d'expérimental » : étant une pièce majeure du futur de XMPP, le travail est long pour obtenir quelque chose de solide et souple. Pour les transports, nous allons donc réutiliser les XEP-0047 et XEP-0065 décrites dans le dernier article, mais en utilisant respectivement les XEP-0261 et XEP-0260 pour les adapter à Jingle. Il faut donc utiliser pas moins de 6 XEPs pour la copie de fichiers avec Jingle (2 d'entre elles servant à la réutilisation d'anciennes), et il est probable que d'autres viennent étendre les possibilités par la suite, en particulier des nouveaux transports (*). Cela peut sembler un peu compliqué, mais c'est ce qui permet la souplesse de Jingle.

Il est possible de modifier ou remplacer à tout moment un transport ou une application, et c'est là la grande force du protocole. Une vidéo passe mal à cause d'une connexion trop faiblarde ? On change l'application pour avoir une vidéo en qualité dégradée. Une connexion SOCKS5 est impossible à établir ? On remplace le transport par un transport « in-band ». Ce dernier cas appelé « plan de secours » (fallback en anglais) était un des problèmes mentionné dans le dernier article, l'ancienne méthode n'indiquant pas comment changer de transport.

Voyons maintenant le fonctionnement. Encore une fois je ne vais pas entrer trop dans les détails, vous pouvez lire la XEP si vous souhaitez les connaître.

Une session Jingle se décide et contrôle à travers le flux XML de XMPP, pour établir une connexion P2P le plus souvent externe (c.-à-d. en dehors du flux XMPP). Une session propose des contenus (« contents »). Un contenu est composé d'une application (transfert de fichier, Vidéo via RTP, etc) et d'un transport (« in-band », « SOCKS5 », « ICE-UDP », etc). L'intérêt principal d'avoir plusieurs contenus est qu'ils sont liés dans la session : par exemple pour une visioconférence, un contenu peut s'occuper de la vidéo, et un autre de l'audio. Si un contenu dans le même logiciel mais non directement lié à la session est utilisé (par exemple un fichier est envoyé au cours de la conversation), on préférera créer une nouvelle session Jingle en parallèle plutôt qu'ajouter un contenu.

Au moment de la création de la session, nous avons 2 entités qui communiquent : l'initiateur (« initiator ») et le destinataire (« responder »). L'initiateur propose des paramètres et/ou une information pour l'application (par exemple des « codecs » pour une vidéo, ou des informations sur le fichier à transférer) ainsi que pour le transport (pour SOCKS5 les candidats par exemple). Si le destinataire accepte la session, il négocie les paramètres en retour pour l'application (par exemple les codecs proposés qu'il connaît) ou le transport (il indique ses propres candidats dans le cas de SOCKS5).

Quand la session est acceptée, elle est considérée « active », mais il n'est pas encore possible d'échanger des données pour autant : il faut d'abord terminer la négociation et accepter un transport (dans le cas de SOCKS5 ça signifie trouver le meilleur candidat, ou changer de transport, probablement pour « in-band »). Une fois tout en place on peut échanger les données, et éventuellement faire des changements en cours d'utilisation comme expliqué plus haut, ou donner des informations (par exemple indiquer qu'un correspondant a coupé le son (« mute »), ou qu'une sonnerie est en cours). Selon les applications, des cas plus compliqués peuvent apparaître, comme changer le sens de transmission de données, rediriger une session (d'un appareil vers un autre par exemple), etc.

Un autre point important avec Jingle, c'est qu'il est possible de demander une pré-condition de sécurité dans une session, par exemple on peut exiger qu'une session soit chiffrée de bout en bout.

Voici une petite liste non exhaustive des améliorations apportées par Jingle rien que pour le transfert de fichiers :

  • une vraie méthode de secours (« fallback »)
  • les XEP-0260 et XEP-261 adaptent les XEP-0065 et XEP-0047 en tirant vraiment profit de Jingle. Ainsi la XEP-0260 permet au destinataire de fournir ses propres candidats, s'inspirant d'une extension jamais standardisée de l'ancienne méthode (appelée « fast-mode »). C'est une grosse avancée, car dans l'ancienne méthode le destinataire doit accepter (et réussir à joindre) les candidats de l'initiateur sinon la connexion échoue. L'échec peut arriver dans de nombreux cas, et si l'initiateur n'a pas de proxy, mais le destinataire en a un, celui du destinataire ne peut pas être utilisé.
    Dans la méthode utilisée avec Jingle, le destinataire peut proposer son proxy, ou la connexion peut s'établir si l'initiateur est injoignable (derrière un NAT par exemple), mais pas le destinataire. L'échec est beaucoup plus rare
  • il est possible de fournir la somme de contrôle (« hash ») quand on le souhaite, et ainsi la calculer au fur et à mesure. Avec l'ancienne méthode c'est tout au début ou rien, ce qui risque de provoquer un ralentissement avant le transfert s'il faut faire le calcul pour un gros fichier
  • avec la XEP-0234, l'initiateur peut demander un fichier au destinataire, au lieu d'uniquement pouvoir lui en proposer un
  • la XEP-0234 permet aussi l'ajout de fichiers en cours de session
  • le chiffrement de bout en bout est possible et prévu, bien que non encore standardisé
  • « ICE-TCP » est en cours de standardisation et devrait arriver cette année (*), permettant de mieux traverser les NATs

Au final, il est quasiment impossible d'échouer un transfert de fichier via Jingle. Le principal cas que je vois est si un des serveurs a une politique interdisant un tel transfert. Cependant, la solution de secours via le flux XMPP « in-band » est gourmande en ressources et très lente, c'est pourquoi il y a du travail sur de nouveaux transports comme ICE-TCP. Ces nouveaux transports serviront à toute application basée sur Jingle : réutiliser l'existant est un des gros points forts de Jingle, et de XMPP en général.

Jingle est une excellente technologie, avec un gros potentiel. Avec PubSub, c'est probablement un des gros piliers du XMPP de demain.

J'en profite pour rappeler que ce blog vient de passer de Dotclear à Salut à Toi, autrement dit il est désormais entièrement basé sur XMPP. J'ai publié une petite série d'articles expliquant la mise en place d'un blog XMPP avec Libervia, son intégration dans une configuration Apache, l'import d'un blog Dotclear et enfin la publication de billets : à lire par ici.

Pour le prochain article, je ne suis pas décidé. Il est possible que je parle de chiffrement de bout en bout vu que c'est un domaine qui bouge en ce moment, ou que je continue sur la lancée Jingle avec les dépôts de fichiers. Cependant j'ai de moins en moins de temps libre, et je préfère consacrer le peu disponible au développement de SàT, le développement de la version bureau/mobiles promise en fin d'année dernière ayant commencé.

(*) cet article ayant été rédigé il y a plusieurs semaines, entre temps la XEP en question est sortie : XEP-0371

Cagou est en chemin9778aa7a-ac86-425d-ab75-db6d3dc1b86e2016-03-28T18:29:53Z2016-03-28T16:53:18Zgoffixmpp:goffi@goffi.org

Un petit billet pour vous dire que suite à notre campagne réussie en fin d'année dernière, le développement sur notre nouvelle interface de bureau et pour appareils mobiles (Android au minimum, peut-être plus) a commencé.

J'ai tenu a faire la migration de mon blog sur SàT avant pour y faire des billets au fil de l'avancement.

Cette interface va s'appeler « Cagou », en référence à la fois à Kivy qui est utilisé, et à la Nouvelle-Calédonie où Souliane (autre développeur principal) et moi nous sommes rencontrés. Le Cagou (ou Kagou) est un superbe oiseau qui aboie et qui ne vole pas, c'est une espèce malheureusement menacée.

L'interface devrait donc fonctionner sur bureau et appareils mobiles, comme promis, mais ne va pas nécessairement suivre les standards auxquels vous êtes peut-être habitués. Par souci de simplification, l'interface sera similaire sur toutes les plate-formes, aussi elle sera pensée pour fonctionner aussi bien avec un écran tactile qu'avec une souris, et il ne faut pas s'attendre à une intégration graphique avec les applications natives de votre bureau. Par contre une intégration avec les fonctionnalités de la plate-forme (notifications, marque-pages, etc) est voulue.

Ce frontal va être pensé pour fonctionner en plein écran (mais aussi en mode fenêtré), éviter tout ce qui est pop-up ou action perturbante (comme les doubles-clics), et elle ne va pas être centrée sur la liste de contacts. Nous en reparlerons bientôt.

Bien entendu, grâce à l'architecture de SàT, vous pouvez vous attendre à voir rapidement toutes les fonctionnalités déjà implémentées (chiffrement de bout en bout, transfert de fichier en Pair à Pair, publication en différentes syntaxes, etc).

Si vous avez des suggestions, des envies ou idées, c'est le moment d'en discuter, soit en commentant ce billet, soit en venant sur le salon sat@chat.jabberfr.org ou en nous écrivant sur contact@salut-a-toi.invalid (remplacez invalid par org). Vous pouvez également écrire sur Diaspora ou SeenThis.

Publiez sur votre blog XMPP depuis Libervia ou jp (SàT)02bfcc6c-f82f-4bc9-b12b-aef8d5a19fc22017-07-14T10:07:11Z2016-03-24T18:55:10Zgoffixmpp:goffi@goffi.org

Articles précédents de la série : Installer une instance de Libervia (SàT) en moins de 10 min, Configuration avancée du conteneur Libervia et Importer un blog Dotclear dans XMPP.

Pour ce dernier article de la mini série sur l'installation d'un blog XMPP avec Libervia, je vais vous expliquer comment publier sur le blog que nous avons mis en place. Ceci fonctionnera également si vous avez un compte Movim (testé), et devrait fonctionner avec Jappix (non testé).

Je vais décrire 2 méthodes : via Libervia, l'interface web, qui est graphique, et la deuxième, pour les utilisateurs avancés, qui se fait via jp, l'interface en ligne de commande.

D'abord quelques explications

Avec XMPP, les blogs sont diffusés en texte pur ou en XHTML, aucun autre langage de balisage n'est utilisé à l'heure actuelle.

Dans SàT, nous faisons la distinction entre billet de blog et microblog avec l'utilisation du titre : nous considérons comme billet de blog un article ayant un titre, et supposé être travaillé, tandis qu'un message court (ou pas, nous n'avons pas de limite artificielle de caractères comme d'autres) sera plus une pensée « sur l'instant », et n'aura pas de titre. À terme nous fournirons sans doute plusieurs flux Atom pour suivre soit la totalité des messages, soit uniquement les billets de blog ou de microblog. Pour le moment les flux diffusent la totalité des messages (ou uniquement ceux correspondant à une étiquette).

D'autre part, nous avons un système permettant d'utiliser n'importe quelle syntaxe pour rédiger un billet. Comme nous ne voulions pas rester bloquer sur telle ou telle syntaxe à la mode, nous permettons la conversion d'une syntaxe à une autre et publions le résultat final en XHTML.

Évidemment la conversion d'une syntaxe à une autre peut provoquer de la perte d'informations de formatage, mais en pratique ça fonctionne relativement bien, et nous comptons faire des améliorations par la suite notamment pour garder le brouillon dans la syntaxe d'origine.

Aujourd'hui, vous pouvez utiliser XHTML bien sûr, mais également Markdown (par défaut) ou la syntaxe wiki de Dotclear pour rédiger un article.

Enfin, tout est unicode avec XMPP, vous pouvez donc utiliser les caractères spéciaux que vous voulez.

Publication via Libervia

La méthode la plus simple pour publier. Dans l'interface de Libervia, sélectionner un « panneau » blog (le panneau que vous voyez à l'ouverture en est un), et cliquez sur la zone de saisie tout en haut. Par défaut vous êtes en mode microblog et en texte simple, il vous suffit de taper votre message et d'appuyer sur [Majuscule] + [entrée] ou de cliquer sur le lien en bas à gauche pour publier votre message.

publication d'un microbillet

Pour un billet plus avancé, vous avez le lien en bas à droite « switch to blog » (passer en mode « blog »). Vous allez ainsi accéder à une zone plus élaborée, avec possibilité de mettre un titre, des étiquettes (« tags ») ou de faire de la mise en forme. Par défaut la syntaxe Markdown est utilisée, mais il est facile de changer dans les préférences via le menu Settings/Parameters/Composition

publication d'un billet de blog

Enfin, notez la case à cocher « preview » (aperçu), qui permet de taper avec un rendu direct un peu comme sur un traitement de texte, fonctionnalité associée à l'acronyme barbare « WYSIWYG ». Voici ce que vous obtenez en cliquant dessus :

publication d'un billet de blog avec aperçu

Une fois satisfait du résultat, vous n'avez plus qu'à cliquer sur « Send message ». En cas d'erreur pas de problème, il est possible d'éditer le message quand vous voulez. En effet les 3 icones sur la droite permettent respectivement de répondre, modifier ou supprimer le message.

icones du message

Tout ce qui vient d'être dit s'applique également aux commentaires.

Les billets que nous venons de publier sont publics, visible par tout le monde y compris les personnes qui n'ont pas de compte XMPP. Mais, spécificité de SàT dans le monde XMPP, il est possible de ne publier que pour un groupe de votre liste de contacts. Pour cela il suffit de cliquer sur le groupe désiré, ou de faire un glissé/déposé de groupe vers la zone des widgets. Un nouveau panneau dédié à ce groupe apparaîtra, vous n'aurez plus qu'à écrire dedans comme précédemment. Il est ainsi facile de ne publier que pour ses amis, ses collègues ou sa famille.

Méthode avancée : publication avec jp

Passons maintenant à la méthode « avancée ». Ici il vaut mieux avoir une version installée normalement plutôt qu'utiliser l'image Docker, car vous pourrez utiliser votre éditeur courant avec sa configuration. Une alternative est de modifier vous-même l'image Docker de jp (salutatoi/jp) en installant votre éditeur favori et en le configurant.

Cette méthode utilise jp, l'interface en ligne de commande de SàT, et donc demande de savoir utiliser un shell, mais elle offre un avantage indéniable de rapidité et d'efficacité : en une commande vous êtes dans votre éditeur de texte favori en train de rédiger votre billet.

Cette commande c'est :

      jp blog edit

    

Une fois validée, vous allez voir votre éditeur s'ouvrir avec le contenu de votre billet dans la syntaxe renseignée dans vos préférences. Un deuxième fichier est créé, avec le même nom que le billet mais qui se termine par « _metadata.json », qui contient les métadonnées de l'article, c'est à dire les informations comme son titre, les étiquettes utilisées, est-ce qu'il faut autoriser les commentaires, etc. Si vous utilisez un éditeur comme Vim ou Emacs, ce deuxième fichier devrait s'ouvrir automatiquement à côté du contenu. Une option particulièrement utile est « publish », que vous pouvez mettre à « false » pour interdire la publication de l'article, évitant toute publication accidentelle tant que votre article n'est pas fini. Une fois satisfait, vous n'aurez qu'à supprimer la ligne et quitter votre éditeur pour voir votre billet publié.

Ci-dessous, une capture de cet article pendant que je le rédige sous Vim :

édition depuis vim

Si vous voulez utiliser un autre éditeur, il suffit de le spécifier avec la variable d’environnement EDITOR, voici par exemple comment éditer avec kate :

      EDITOR=kate jp blog edit

    

Il est également possible de spécifier la commande à utiliser dans sat.conf, avec l'option « editor » dans la section « [jp] ».

En plus de créer un nouveau billet, il est possible d'éditer un billet existant, ou de continuer un brouillon non publié. 3 mots clefs sont utilisables à l'heure actuelle :

  • new permet de créer un nouveau billet, c'est l'option par défaut et nous venons donc de l'utiliser

  • last édite le dernier billet publié, particulièrement pratique pour corriger une faute

  • current édite le brouillon en cours (billet avec la métadonnée « publish » mise sur « false »)

ainsi pour faire une mise à jour du dernier billet, il suffit d'entrer:

      jp blog edit last

    

Plutôt simple non ?

Prévisualisation

Passons la plupart des options pour indiquer titre ou étiquette — il vous suffit de taper « jp blog edit --help » pour les connaître — et attardons-nous sur l'option « --preview ».

jp est capable d'ouvrir le brouillon en cours et d'afficher une prévisualisation dans le navigateur par défaut, et il va le mettre à jour à chaque enregistrement du fichier.

Par défaut, un nouvel onglet sera ouvert à chaque enregistrement, pas très pratique. Il est cependant possible de mettre à jour l'onglet en cours, soit via D-Bus pour un navigateur comme Konqueror (qui a la bonne idée de permettre ainsi de rafraîchir la page), soit via un outil externe, « xdotool » qui permet de piloter une application sur un serveur X (il faut donc installer cet outil pour que cela fonctionne).

2 options dans sat.conf sont prévues pour contrôler la prévisualisation : blog_preview_open_cmd pour l'ouverture du fichier, et blog_preview_update_cmd pour la mise à jour. Ces 2 options demandent des commandes shell, dans lesquelles {url} sera substituées par L'URL du fichier (de la forme file:…) et {preview_file} sera substitué par le chemin vers le fichier de prévisualisation.

Voici la recette pour une prévisualisation automatique avec Konqueror (qdbus doit être installé), à mettre dans sat.conf section [jp] :

      blog_preview_open_cmd = konqueror {url}
blog_preview_update_cmd = /bin/sh -c "qdbus $(qdbus org.kde.konqueror\*) /konqueror/MainWindow_1 reload"

    

Et celle pour Firefox (ou autre, changez « Mozilla Firefox » par ce qui vous intéresse) :

      blog_preview_open_cmd = firefox -new-tab {url}
blog_preview_update_cmd = /bin/sh -c "WID=$(xdotool search --name 'Mozilla Firefox' | head -1); xdotool windowactivate $WID; xdotool key F5"

    

Vous pouvez maintenant tester avec jp blog edit --preview. Si vous avez oublié le --preview, vous pouvez lancer la prévisualisation après coup grâce à jp blog preview.

Éditer un billet déjà publié

Si vous voulez éditer un billet déjà publié (et autre que le dernier, sinon last suffira), vous pouvez entrer directement son URL XMPP. Ainsi, si je veux éditer le premier article de cette série, je n'ai qu'à faire :

      jp blog edit --preview "xmpp:goffi@goffi.org?;node=urn%3Axmpp%3Amicroblog%3A0;item=067646bd-9439-430a-98c2-c655f5a63e40"

    

Mais il y a encore plus simple ! Vous pouvez entrer directement l'URL HTTP(S), et si le client XMPP fournir l'URL xmpp: dans la page (ce qui est le cas de Libervia), jp retrouvera le billet. Ainsi je peux entrer directement :

      jp blog edit --preview "http://www.goffi.org/blog/goffi/067646bd-9439-430a-98c2-c655f5a63e40"

    

Oui ça semble assez magique, c'est la standardisation qui permet cette magie !

Conclusion

Voilà qui conclut cette petite série sur l'installation d'un blog XMPP. La dernière partie est clairement pour utilisateurs avancés, mais il semblait intéressant de la mettre pour montrer une partie des possibilités de SàT. Par la suite je ferai des articles de temps en temps quand une fonctionnalité intéressante aura été ajoutée.

Si vous avez installé un blog XMPP, que ce soit avec Libervia ou autre, n'hésitez pas à me contacter que je vous ajoute dans mes contacts (ou ajoutez-moi directement ! goffi@jabber.fr, ce blog est sur une autre adresse : goffi@goffi.org).

Les prochains articles — en dehors d'un épisode de « parlons XMPP » en attente de publication — parleront très probablement de l'avancement sur « Cagou », la future interface bureau/Android, promise suite au succès de notre financement participatif, à bientôt !