Accueil > .Net, Développement, Qualité > SonarQube et la qualité du code

SonarQube et la qualité du code

Récemment, nous avons voulu mettre en place divers instruments pour renforcer la qualité de notre code.
Nous avons déjà ReSharper pour les « besoins quotidiens », mais nous avons aussi besoin de certains autres indicateurs que ReSharper ne fournit pas.
Du coup, il y a besoin d’avoir d’autres outils.

Je connaissais déjà NDepend pour avoir utilisé les versions d’essais à titre personnel.
J’ai décidé de ne pas l’inclure du fait que je ne sais pas encore de quel moyens je dispose (en termes de temps comme des ressources financières).

Il y en a d’autres, je vous renvoie à stackoverflow : What static analysis tools are available for C#?.
Un chef de projets qui était passé et que je connais bien nous avait vanté les mérites de SonarQube. Etant sous license LGPLv3, SonarQube nous permettait de satisfaire au prérequis.
Du coup, voici mon petit retour d’expérience à ce sujet.

 
 
A titre d’information, pour ce qui est sécurité, il y a aussi Netspark, conseillé par Troy Hunt.
Dans son billet, il parle d’une Community Edition qui n’existe plus.

 

Qu’est-ce que c’est ?

 

Donc, SonarQube est un outil d’analyse de code qui permet d’examiner la qualité du code selon 7 axes particuliers.
SonarQube - 7 axes
Il prend en charge nativement plusieurs langages dont le C# et le Javascript (pour ceux qui nous intéresse le plus).

Pour tout ce qui est du rendu, SonarQube se base sur un site Web présentant un dashboard général ainsi qu’un dashboard par projet.
Il est ensuite possible de naviguer dans les différents axes, via : « Technical Debt », « Coverage », « Duplications », « Structure » et « Issues » (pour les principaux).

 

Mise en place

 

SonarQube est en Java, donc, il faut déjà avoir installé, à minima, la JRE.
La dernière version en date de la JRE est disponible ici.

Ensuite, il faut télécharger SonarQube et le décompresser.
De même, il faut télécharger et décompresser le scanner.

Dans la suite du billet, je vais supposer que SonarQube est décompresser dans %SonarQube% et le scanner dans %Scanner%.

Pour les développements C#, il est possible de changer le plugin mais aussi de se baser sur MSBuild.
Dans ce cas, il faut télécharger le plugin C# (5.1 actuellement).
Il faut ensuite positionner le fichier *.jar dans %SonarQube%\extensions\plugins :
SonarQube - Csharp Plugin

Ensuite, il faut aller chercher le scanner pour MSBuild.
Je vais supposer dans le billet que ce scanner est décompressé dans %ScannerMSBuild%.

Une fois tout cela réalisé, il faut lancer SonarQube.
Il suffit de lancer une invite de commandes et de se positionner dans le répertoire %SonarQube%\bin\windows-x86-32 (32 ou 64, c’est selon).
Après, il faut lancer (à minima, elles m’ont suffit) les deux commandes suivantes :

InstallNtService.bat
StartSonar.bat

Par la suite, il ne faut pas fermer cette invite de commandes !

 

Utilisation des sources SonarQube

 

Dans un premier temps, je vais montrer comment utiliser SonarQube pour du code qui n’est pas spécifiquement du C# (comportement de base, donc) en me basant directement sur les sources de SonarQube, disponibles ici.

Par défaut, le scanner se base sur le fichier « sonar-project.properties » pour sa configuration. Il faut donc qu’il soit présent.
Je ne vais pas analyser tout le code de SonarQube, mais une petite partie
SonarQube - Scan

Ce qui donne le fichier suivant :

sonar.projectKey=SonarQube
sonar.projectName=SonarQube
sonar.projectVersion=1.0

sonar.host.url=http://localhost:9000
sonar.language=java
sonar.sourceEncoding=UTF-8
sonar.exclusions=**/*.sh, **/*.xml, **/*.txt

sonar.sources=src

sonar.modules=sonar-core, sonar-db, sonar-home

sonar-core.sonar.projectName=sonar-core
sonar-db.sonar.projectName=sonar-db
sonar-home.sonar.projectName=sonar-home

Pour les différents paramètres, la documentation remplie, un peu, son rôle.
Ceci dit, je vais revenir sur plusieurs éléments.

  • sonar.projectKey : identifiant unique du projet
  • sonar.host.url : url du site de SonarQube, peut être en local ou non
  • sonar.language : langage utilisé, il est possible de le force (et donc seul[s] ceux qui sont mentionnés seront utilisés ou de laisser ouvert)
  • sonar.exclusions : pour exclure des éléments, il y a une syntaxe à respecter
  • sonar.sources : dans l’explorateur de fichier, chaque module (sonar-core, sonar-db, sonar-home) possède un répertoire « src » dans lequel sont positionnés les sources, c’est de ça qu’on parle ici
  • sonar.modules : liste des différents modules à scanner, les valeurs sont dans l’explorateur de fichiers ET servent de clefs ([module] ci-après) pour la suite
  • [module].sonar.projectName : nom des différents modules

Pour 602 fichiers, le scan a pris un peu plus d’une minute sur ma machine.

 

Dashboards

 

En allant sur le site créé par SonarQube (par défaut http://localhost:9000), il est possible d’afficher un dashboard général :
SonarQube- Dashboard Général

Il est ensuite possible de naviguer sur les dashboard des projets :
SonarQube - Dashboard Projet SonarQube

Dans les deux cas, on a rapidement des indicateurs de la qualité générale des projets.
Ce qui est très intéressant, c’est qu’il est rapidement possible de voir la santé générale du projet via la dette technique, ainsi qu’une idée de la charge pour la prendre en compte :
SonarQube - Dette technique

Mais surtout, ce qui est encore plus intéressant, c’est que SonarQube va créer des « Issues », l’équivalent de « defects », « workitem » ou autre : c’est-à-dire des points de départ pour traiter la dette technique qui peuvent être pris en charge par les développeurs.
SonarQube - Issues

Et, à mon sens, c’est bien là l’intérêt de SonarQube : il ne sert pas seulement à avoir de vagues indicateurs, mais donne des pistes réelles et tangibles pour améliorer les choses.
Il est donc possible de se créer des comptes directement sur le site (il y a un compte par défaut : admin/admin) et donc d’affecter les « Issues » aux développeurs.
Il y a même un plugin LDAP qui permet d’avoir les utilisateurs de l’Active Directory.

 

MSBuild

 

Jusqu’à présent, on a vu comment scanner un projet et quelques éléments du dashboards (il y en a plein d’autres, mais ça serait trop long et eu pertinent de tous les passer en revue).
Maintenant, le principal : comment intégrer MSBuild pour scanner des projets en C# ?

Si vous avez bien suivis la première partie (Mise en place), les plugins pour le C# et pour MSBuild sont déjà installés.

Dans le cas du scanner de base, le fichier de configuration utilisé est le « sonar-project.properties ».
Dans le cas du scanner pour MSBuild, c’est un fichier « SonarQube.Analysis.xml ». Il y en a déjà un, assez basique, à côté de l’exécutable (dans %ScannerMSBuild%).

Dans mon cas, je vais en utiliser un additionnel :

<?xml version="1.0" encoding="utf-8" ?>
<SonarQubeAnalysisProperties  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://www.sonarsource.com/msbuild/integration/2015/1">
  <Property Name="sonar.host.url">http://localhost:9000</Property>
  <Property Name="sonar.projectDescription">Description du projet</Property>
  <Property Name="sonar.exclusions">_ReSharper.*/*, _Setup/*, _SharedBinaries/*</Property>
</SonarQubeAnalysisProperties>

Les propriétés sont très similaires, donc pas de grosses surprises.

C’est pour lancer le scanner que les choses sont bien différentes.
J’ai créé un fichier *.bat pour lancer le tout, histoire de pas me taper les commandes à la main :

%ScannerMSBuild%\MSBuild.SonarQube.Runner.exe begin /key:ProjectKey /name:ProjectName /version:1.0 /s:%racine_du_projet_ou_config_commune%\SonarQube.Analysis.xml
"C:\Program Files (x86)\MSBuild\14.0\Bin\MSBuild.exe" /t:Rebuild
%ScannerMSBuild%\MSBuild.SonarQube.Runner.exe end

Trois étapes sont clairement identifiées :

  • Dans un premier temps, il faut « initier » l’environnement de travail.
  • Ensuite, il faut rebuilder la solution grâce à MSBuild
  • Enfin, lancer réellement le scanner

Le processus est différent, mais le résultat est similaire. Le tout va être envoyé au site Web qui va afficher tout proprement comme indiqué plus haut.
Pour exclure des éléments de la solution, il est possible de les spécifier directement dans les csproj : Excluding Artifacts from the Analysis. C’est un peu plus lourd, mais ça peu valoir le coup.

Il est également (et c’est un très gros intérêt) possible de greffer le tout sur une build (pour…au hasard de l’intégration continue) : Analyzing with SonarQube Scanner for MSBuild.

 

Conclusion

 

SonarQube, s’il est parfois un peu casse-gueule dans sa mise en route, me semble plutôt bien réussit et d’une aide potentielle énorme.
Les dashboards sont vraiment clairs et pertinent, on sent qu’il y a une réelle reflexion derrière.
Par contre, SonarQube n’est pas réellement extensible, surtout en C#. Il sera donc possible d’activer ou de désactiver des règles, d’en modifier leur niveau (Blocker, Critical…), mais ça reste tout.

A voir ce que cela donne dans un usage plus poussé qu’un PoC et si, au final, il aide vraiment à améliorer les choses.
Je ne sais pas si on va le pousser, mais si c’est le cas, j’essayerais de faire d’autres retours.

Catégories :.Net, Développement, Qualité
  1. 16/08/2016 à 15:04

    Votre article tombe bien. J’avais justement l’intention de mettre en place sonarcube pour des projets JAVA, mais s’il marche avec VS c’est autant de temps de gagner pour le tester pour moi.
    merci

  1. 16/09/2016 à 07:50

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s

%d blogueurs aiment cette page :