Écrire des diagrammes de séquences

Posté par . Édité par Davy Defaud, Benoît Sibaud, jcr83 et palm123. Modéré par ZeroHeure. Licence CC by-sa
26
16
sept.
2016
Graphisme/photo

Les diagrammes de séquences sont très utiles pour représenter le déroulement d’événements au fil du temps. Ils sont par exemple très utilisés pour décrire des protocoles de communication, où les paquets d’information se croisent, se perdent, passent du temps dans les tuyaux.

Dans la seconde partie de la dépêche, après avoir expliqué leur principe de ces diagrammes, quelques logiciels existants seront listés et un nouveau venu sera présenté.

Les diagrammes de séquences sont très utiles pour représenter le déroulement d’événements au fil du temps. Ils sont par exemple très utilisés pour décrire des protocoles de communication, où les paquets d’information se croisent, se perdent, passent du temps dans les tuyaux.

Ces diagrammes comportent :

  • des acteurs, avec leur ligne de vie (un acteur peut représenter une personne, une machine, un processus, un fil d’exécution…). La spécification UML utilise le terme de « participant » ;
  • des messages échangés entre acteurs.

On fait ces dessins au tableau, puis on les efface, mais parfois on voudrait les inclure dans une page d’un document, ou les envoyer par courriel.

Logiciels existants

Des outils logiciels existent, pour générer de tels diagrammes :

  • éditeur de texte (ASCII art) ;
  • Mscgen (http://www.mcternan.me.uk/mscgen) ;
  • éditeurs dits UML ;
  • éditeurs SDL (Specification and Description Language) ;
  • éditeurs de diagrammes : Dia, LibreOffice, Microsoft Visio, etc. ;
  • outils d’ingénierie système (Capella…).

Mais pour le moment, je ne suis pas satisfait de ceux que j’ai utilisés. Je voudrais les possibilités suivantes :

  • créer un acteur ou le détruire au cours du temps ;
  • croiser les échanges de messages ;
  • perdre un message ;
  • indiquer l’expiration d’un temps imparti (timeout) ;
  • faire une mise en page du dessin sans dessiner (j’entends par là que je ne veux pas passer trop de temps à déplacer à la souris les éléments pour les aligner ou les relier, et puis tout décaler un par un parce que j’ai inséré un nouvel acteur en plein milieu…) ;
  • avoir un logiciel libre et gratuit.

Si quelqu’un connaît un tel logiciel, je suis preneur.

Et alors ?

En attendant, j’ai fait un prototype d’un tel logiciel, que j’appelle pour le moment meseq sur le principe de mscgen :

  • on écrit un fichier texte décrivant le scénario ;
  • meseq génère une image PNG à partir de ce fichier.

L’avantage de cette approche est la simplicité et la rapidité de développement de l’outil, mais l’inconvénient est que c’est moins ergonomique qu’un éditeur avec rendu WYSIWYG.

J’ai mis au point une syntaxe rudimentaire pour le fichier d’entrée. Je sais déjà que je vais la modifier pour la rendre plus évolutive.
Voici un exemple pour illustrer cette syntaxe (fichier .msq) :

[init]
actors w3client proxy "" w3server

[scenario]

w3client   ->   proxy   CONNECT
w3client   <-   proxy   OK
w3client   ->   proxy   bytes
proxy      ->   w3server bytes
:
w3client  <->   w3server "TLS Handshake\nwhat follows is ciphered"
:
:
w3client   ->    proxy   "GET /index.html"
proxy      ->   w3server "GET /index.html"
proxy      <-   w3server "200, index.html"
w3client   <-    proxy   "200, index.html"

Et voici l’image générée par meseq (plus complète que l’exemple ci‐dessus) :

example_web.msq.png

Autre exemple, avec flèches qui se croisent, etc. :

example_piggyback.msq.png

Show me the prototype

Ce prototype est là pour étudier la faisabilité, présenter mes idées et expérimenter.
Bon, il est codé vite et mal : non documenté, bogué, mal structuré… Bref, un vrai code de goret.

Ce prototype et les exemples sont sur Github : https://github.com/goeb/meseq.

On utilise les bibliothèques Cairo et Pango pour dessiner, écrire le texte, puis générer l’image. Elles sont relativement simples à utiliser.

Il existe d’autres bibliothèques pour dessiner, que je n’ai pas étudiées (et je ne suis pas sûr qu’il existe un moyen simple de les utiliser en Python) :

  • libgd, utilisée par mscgen ;
  • les bibliothèques sous‐jacentes de Graphviz (dont le rendu est agréable).

Pour la suite

Les améliorations à faire sont :

  • améliorer le rendu (diagramme plus compact verticalement, réduire les conflits de textes qui se superposent…) ;
  • ajouter des visuels (bloc de commentaire, couleurs…) ;
  • augmenter la qualité de code ;
  • choisir une licence libre.

Par la suite, je porterai peut‐être ce programme en C ou C++, afin qu’il soit plus facile d’accès pour les personnes ne disposant pas de Python sur leur poste (je pense aux personnes lambda sur système d’exploitation Windows).

Afin d’orienter les choix qui restent à faire, je serais intéressé par les avis éclairés des lecteurs de LinuxFr.org :

  • utilisez‐vous les diagrammes de séquences ?
  • quels éléments visuels trouvez‐vous indispensables, et pour représenter quoi ?
  • faut‐il rester en Python ou passer en C ou C++ ?

N. D. M. : voici une liste des liens apparus dans les commentaires du journal :

  • # Autres soft

    Posté par . Évalué à 2. Dernière modification le 16/09/16 à 19:31.

    Je ne sais pas si ça correspond au besoin de l'auteur, mais ça servira éventuellement à d'autres, le logiciel yEd (multiplateforme && gratuit mais pas opensource) est bien utile pour les diagrammes.

    • [^] # Re: Autres soft

      Posté par . Évalué à 1.

      Je connais un peu Yed. Il fait de très jolis rendus, avec équilibrage automatique de graphe hiérarchique, par exemple. Mais il ne fournit pas de facilité particulière pour les diagrammes de séquence. Ça reste du positionnement de boites et de flèches à la souris.

  • # PlantUML

    Posté par (page perso) . Évalué à 4.

    Je suppose que ça rentre dans la section des « éditeurs UML », mais PlantUML présente une syntaxe vraiment proche de ce que tu présentes.

    J'écris tous mes diagrammes ainsi (pro ou pas), et c'est pas mal.

    L'as-tu testé ?

    • [^] # Re: PlantUML

      Posté par . Évalué à 1.

      J'ai regardé les exemples de PlantUML. Il est intéressant, mais ne semble pas capable de croiser les flèches. Et la destruction d'un acteur n'arrête pas sa ligne de vie.

      • [^] # Re: PlantUML

        Posté par . Évalué à 1.

        git clone https://github.com/plantuml/plantuml et bon courage ! :)

      • [^] # Re: PlantUML

        Posté par . Évalué à 2.

        L'auteur de PlantUML est très réactif et peut prendre en compte tes propositions d'améliorations (quand cela demande pas de grosses modifications de code, c'est souvent immédiat). L'auteur principal est français.

        Je suis moi aussi un très gros utilisateur de plantUML car on peut l'intégrer dans une multitude d'outils (d'Emacs à libreOofice en passant par doxygen ou les wiki) et sa syntaxe est simple à assimiler. De plus, il couvre une très grande partie d'UML.

        Concernant les diagrammes de séquence, effectivement, tu ne peux pas croiser tes messages, par contre, tu peux modéliser la perte de message (transition puit et source possible).
        Pourquoi as-tu besoin de croiser tes messages (les relations d'ordres entre les messages UML sont toujours partielles, selon la norme) ?

        • [^] # Re: PlantUML

          Posté par . Évalué à 4.

          Pourquoi as-tu besoin de croiser tes messages (les relations d'ordres entre les messages UML sont toujours partielles, selon la norme) ?

          Comme ça je dirais que c'est pratique quand tu veut décrire un scénario dans un système P2P avec des évènements qui arrivent sur 2 nœuds simultanément.

          Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

        • [^] # Re: PlantUML

          Posté par . Évalué à 5.

          Pourquoi as-tu besoin de croiser tes messages

          Dans la vraie vie, les messages se croisent souvent.

          Exemple : une page web. Le navigateur envoie plusieurs requêtes en parallèle pour récupérer les composants de la page (images, javascript, css,…). Et il reçoit les réponses en parallèle. Donc des requêtes et des réponses se croisent.

  • # Une alternative

    Posté par . Évalué à 2.

    Ce type d'outils existe en ligne - peut-être pas aussi poussé que votre besoin.
    Voir par exemple ici : https://www.websequencediagrams.com/

    (je ne suis lié en aucune manière à ce site)

  • # Aller encore plus loin

    Posté par . Évalué à 1.

    Les diagrammes de séquence sont très bien, mais il est possible d'aller plus loin en modélisant tout son logiciel en UML et en générant une partie du code source. La génération de code se fait alors à partir des diagrammes de classe et des diagrammes d'etat/transition.
    A ce titre, en logiciel libre, on peut notamment cité PapyrusRT, encore immature mais très prometteur, développé par le CEA LIST. Il pourrait d'ailleurs faire l'objet d'un article, à mon avis.

    • [^] # Re: Aller encore plus loin

      Posté par . Évalué à 3.

      […] il est possible d'aller plus loin en modélisant tout son logiciel en UML et en générant une partie du code source.

      Qu'entends-tu par « partie » ? Faut-il modifié le code généré ? Si oui lorsque l'on fait une évolution, il faut alors regénérer puis re-modifier ces même sources ?

      Mais les diagrammes de séquence ne servent pas qu'à ça, hein ? Tu peut vouloir présenter un cas précis de communication entre un serveur sur le quel tu n'a pas la main et ton client, tu peux présenter des choses à un assez haut niveau, tu peux voir ça à partir d'une trace généré (par exemple une capture tcpdump),…

      Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

      • [^] # Re: Aller encore plus loin

        Posté par . Évalué à 2.

        Oui, je suis assez d'accord avec toi : il ne faut pas confondre l'utilisation de diagramme à vocation architecturale de diagramme à vocation de conception (objet en général quand on parle d'UML).

        Papyrus et la génération automatique cible plutôt la conception alors que les exemples que tu cites sont plutôt architecturaux et ne se retrouve pas "simplement" comme du code étant généré.

        Bien sûr un overlap entre ceux deux mondes existe (heureusement ).

      • [^] # Re: Aller encore plus loin

        Posté par . Évalué à 1.

        Avec les diagrammes de classes, tu génères le prototype de classe. Comme le modeleur permeur de rentrer le code des méthodes, tu génères tout en une fois. Pour les statecharts, tout est généré sans besoin de modification, non plus.
        Avec PapyrusRT (à ne pas confondre avec Papyrus tout court), viennent les runtimes qui permettent d'exécuter pour windows, linux, etc…
        L'avantage est d'avoir une conception qui ne dévie jamais du code (ou plutôt l'inverse !)

        Papyrus et PapyrusRT font partie de Polarsys, évoqué dans une autre réponse plus bas.

        • [^] # Re: Aller encore plus loin

          Posté par . Évalué à 1.

          Je précise que Papyrus et PapyrusRT sont des plugins Eclipse.
          PapyrusRT est une "surcouche" à Papyrus pour les logiciels temps réel, il offre tous les moyens de com inter-taches (les ports), générateur de code, etc…

      • [^] # Re: Aller encore plus loin

        Posté par . Évalué à 1.

        Bien sûr ! On peut aussi faire la spec en UML, mais évidemment, on ne va pas en générer du code !

    • [^] # Re: Aller encore plus loin

      Posté par (page perso) . Évalué à 3.

      tu veux écrire une dépêche sur le sujet ?

      Speed dating is useless. 30s isn't long enough to explain the benefits of functional programming in Haskell

    • [^] # Re: Aller encore plus loin

      Posté par . Évalué à 1.

      Les diagrammes de séquence sont très bien, mais il est possible d'aller plus loin en modélisant tout son logiciel en UML et en générant une partie du code source

      Attention, on ne veut PAS cela, dans les cas suivants :

      • quand les logiciels sont déjà faits
      • quand on ne parle pas de logiciel mais de machines ou de personnes
      • quand on veut exposer une anomalie
  • # Sirius

    Posté par (page perso) . Évalué à 6.

    Pour faire des diagrammes de séquences, tu peux utiliser Sirius.
    C'est un projet Open Source sous licence EPL.
    Voici le type de résultat que tu pourrais obtenir : seq

    Les fonctionnalités de diag de séquences te permettent de faire à peu près tout ce qu'on trouve classiquement dans ce type de diagramme, cf la doc : http://www.eclipse.org/sirius/doc/specifier/sequences/Sequence%20Diagrams.html

    Mais il y a un avantage particulier : tu peux complètement choisir le format que tu souhaites utiliser pour stocker tes données, et tu peux personnaliser complètement le rendu graphique.
    Si tu veux t'y essayer, mieux vaut commencer par un diagramme classique en suivant le tuto : http://www.eclipse.org/sirius/getstarted.html

    Je connais deux outils basés sur Sirius qui sont eux mêmes Open Source et qui fournissent des diagrammes de séquences :
    - UML Designer (ça m'a d'ailleurs étonné que ne cite pas ce projet Open Source dans la liste des projets libres qui font de la modélisation UML : http://www.umldesigner.org/ ). Le diag de seq : http://www.umldesigner.org/ref-doc/implement-the-application.html#Sequence_Diagram
    - Capella, pour modéliser des architectures http://polarsys.org/capella/ et qui lui exploite toutes les capacités du moteur Sirius de diagramme de séquences : http://polarsys.org/capella/images/start/diagrams/[ES]_SAR.png

    • [^] # Re: Sirius

      Posté par . Évalué à 0.

      D'ailleurs tout un article sur Polarsys ne serait pas de trop non plus !

  • # Un petit lien de plus..

    Posté par . Évalué à 1.

    Merci pour tout ces liens !

    Avec beaucoup de retard, je vous en donne un de plus :

    http://nomnoml.com/

    Attention néanmoins, ici on ne peut pas de faire de diagrammes de séquences mais seulement de classe et d'états. De plus, j'ai pas bien compris la licence…

  • # actdiag, mermaid et d'autres en passant

    Posté par . Évalué à 0. Dernière modification le 17/09/16 à 22:46.

    Sinon il y a aussi actdiag et mermaid.
    En fait, j'avais passé du temps à chercher une flopée d'outils du genre et les voilà :
    * PlantUML pour tout UML, comme dit dans d'autres réponses
    * Ditaa pour transformer de l'ascii moche en joli diagramme
    * shaape idem
    * blockdiag diagrammes tout bêtes ou autres (c'est une suite de softs)
    * mermaid pour des tas de schémas encore.

  • # Il ya aussi ... graphviz

    Posté par . Évalué à 5. Dernière modification le 18/09/16 à 10:35.

    Bon c'est juste histoire de rajouter un lien :

    Graphviz et sa galerie

    mais c'est un outil plein de surprises :)

  • # open modelsphere

    Posté par (page perso) . Évalué à 0.

    il y a open modelsphere qui est très complet

    http://www.modelsphere.com/org/fr/open_modelsphere.html

    www.solutions-norenda.com

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.