STAGE EFFECTUÉ DU 14 AVRIL AU 20 JUIN 2003

À SELLIGENT (CHARLEROI BELGIQUE)

M E MO I R E D E ST A GE

Intégration d’un outil de surveillance à un logiciel existant

Maître de stage
Michel Wrzesien - Team Leader Web Development
Selligent Corporate

Etudiant
Rémy Liscia - Informatique 2ème année

Institut Universitaire de Technologie de Rodez (représenté par Mr Barrios)

Remerciements
Je tiens particulièrement à remercier l’équipe “Recherche et
Développement” de Selligent qui m’a accueilli dans ses locaux de
Charleroi, à commencer par le directeur technique : Monsieur Thierry
Téchy, le directeur du département R&D : Monsieur Michel Wrzesien, ainsi
que Jenny Migliore, Pascal Evrard et Walter Tricknot qui ont suivi mes
travaux et qui m’ont apporté toute l’aide dont j’avais besoin.
Un grand merci aussi à Monsieur Barrios, professeur à l’IUT, qui a suivi
mon stage depuis Rodez et qui n’a jamais été avare de conseils.
 SOMMAIRE

1-LE CONTEXTE DU STAGE.............................................................5

1.1-Le pays : la Belgique...................................................................5
1.2-L’entreprise : Selligent................................................................5
1.3-L’activité : la CRM.......................................................................7
1.4-Les logiciels édités......................................................................7
1.4.1-Philosophie de Selligent.........................................................7
1.4.2-Logiciels édités par Selligent...................................................8
2-LOGICIEL SELLIGENT XI FOR WEB.............................................9
2.1-Présentation..............................................................................9
2.2-Fonctionnalités CRM....................................................................9
2.3-Technologies utilisées..................................................................9
2.3.1-Architecture DNA et COM.......................................................9
2.3.2-Architecture .NET................................................................10
2.3.3-Programmation avec C#.......................................................12
2.3.4-Interfaçage avec ASP et ASP.NET..........................................13
2.3.5-Architecture Selligent .NET...................................................13
2.4-Conclusion...............................................................................17
3-DESCRIPTION DU PROJET........................................................18
3.1-Contrat....................................................................................18
3.2-Présentation.............................................................................18
3.3-Fonctionnalités.........................................................................18
3.4-Utilisateurs..............................................................................18
3.5-Fonctionnement détaillé.............................................................19
4-ETAPES DU PROJET..................................................................20
4.1-Documentation.........................................................................20
4.2-Analyse...................................................................................21
4.3-Développement........................................................................23
4.4-Tests.......................................................................................29
4.5-Récapitulatif.............................................................................30
5-LE BILAN DU STAGE.................................................................31
5.1-Bilan du projet..........................................................................31
5.2-Un stage à l’étranger.................................................................31
5.3-Un stage en entreprise..............................................................32
5.4-Un stage de fin d’études............................................................33
ANNEXES.....................................................................................34
Glossaire.......................................................................................34
Bibliographie..................................................................................36
Chronologie du stage......................................................................37
Documents produits lors de l’analyse du projet...................................38
Brochure de publicité......................................................................38
 Intégration d’un outil de surveillance à un logiciel existant - Le contexte du stage

1-Le contexte du stage

1.1-Le pays : la Belgique

Guère plus étendue que la région Midi-Pyrénées mais peuplée d'environ
dix millions d’habitants, la Belgique est une monarchie parlementaire qui
est composée de plusieurs communautés linguistiques, source de
nombreux conflits locaux et de nationalismes exacerbés : les Flamands
néerlandophones, les Wallons francophones et une minorité
germanophone.
Treizième puissance mondiale, la Belgique a connu une industrialisation
lourde (sidérurgie, exploitation minière). Ces activités aujourd'hui
sinistrées sont peu à peu remplacées par des industries de pointe
(biomédecine, télécommunications, aviation, etc) et des activités
tertiaires.
C'est à Gosselies, près de Charleroi, dans une région où cette
reconversion est aussi difficile à mettre en oeuvre qu'urgente, que se situe
le siège social de Selligent, l'entreprise dans laquelle j’ai effectué mon
stage.

1.2-L’entreprise : Selligent
Selligent est un éditeur de logiciels destinés aux moyennes entreprises.
Cette société Wallonne créée en 1990 compte aujourd’hui des filiales en
Allemagne, au Canada et en France. Ses partenaires de distribution
couvrent toute la planète : Europe, Asie, Amérique du Nord, Golfe et
Afrique du Nord. Les logiciels qu’elle édite sont des logiciels de CRM
(Customer Relationship Management, en français GRC : Gestion de la
Relation Clientèle).
Les 45 employés du siège à Charleroi sont en charge de la R&D (recherche
et développement), des contrôles qualité (tests), du help desk (assistance
clientèle), du marketing et de l’administration.
Employant 90 personnes dans tout le groupe (principalement des
commerciaux et des intégrateurs, qui vendent, personnalisent et installent

Rémy Liscia 5
 Intégration d’un outil de surveillance à un logiciel existant - Le contexte du stage

les logiciels pour les sociétés clientes), Selligent revendique 35000

utilisateurs à travers le monde.
Très présente sur le marché français (la moitié des ventes est effectuée en
France), quelques uns de ces clients sont : Club Med, Lexmark, Gaz de
France, France Telecom, Axa, Siemens, etc.
D’un point de vue économique, Selligent se porte bien : son chiffre
d’affaires était de 2.9 millions d’euros en 1998, il a atteint 9 millions
d’euros en 2002. Depuis la crise des nouvelles technologies, l’entreprise a
vécu des moments délicats et a dû procéder à des restructurations
organisationnelles. Le retour au bénéfice est prévu pour cette année.
Au niveau de la concurrence, le marché de la CRM est très vaste. Des
sociétés comme Siebel ou SAP occupent le marché des très grandes
entreprises. Les petites entreprises sont clientes d’éditeurs comme Act ou
encore Archie. Selligent se situe entre les deux, avec des transactions
variant entre 50 et 500 licences. Dans ce secteur, des concurrents
existent (PeopleSoft, Onyx) mais le marché est en constante
augmentation. L’annonce de l’arrivée prochaine d’un produit Microsoft de
CRM sur le marché européen ne menace en rien Selligent : en effet,
Microsoft s’adresse plus aux entreprises de petite taille et Selligent a pour
avantages le multilinguisme et une approche européenne.

Marché européen de la CRM

 Intégration d’un outil de surveillance à un logiciel existant - Le contexte du stage

1.3-L’activité : la CRM
Aussi appelée Gestion de la Relation Clientèle (GRC), la CRM permet aux
entreprises de mettre en avant les relations qu’elles ont avec leurs clients,
relations axées sur le cycle prospection, vente, maintenance et relance.

Prenons des exemples : un logiciel qui permet de sauvegarder les

coordonnées des clients et d’effectuer du publipostage est un logiciel de
CRM. De même qu’une application disponible sur assistant personnel
(PDA) qui permet à des représentants de recueillir à tout endroit des
informations sur leurs clients. Bien évidemment, et comme évoqué plus
haut, les besoins sont différents selon les entreprises et Selligent propose
une solution logicielle de CRM beaucoup plus élaborée.

1.4-Les logiciels édités

1.4.1-Philosophie de Selligent
Les logiciels proposés par Selligent répondent à une philosophie global
and local. Ceci signifie que les développeurs de Selligent fournissent une
application de base très complète mais entièrement personnalisable
(fonctionnel et design) et à laquelle peuvent s’ajouter des composants
programmés supplémentaires, adaptés à l’activité de l’utilisateur. La
personnalisation de l’application et l’ajout de nouvelles fonctionnalités sont
effectués soit par l’entreprise utilisatrice (administrateurs, services
informatiques, etc), soit par des intégrateurs et consultants partenaires ou
employés de Selligent.
 Intégration d’un outil de surveillance à un logiciel existant - Le contexte du stage

1.4.2-Logiciels édités par Selligent

Selligent édite deux logiciels qui ont les mêmes fonctionnalités mais dont
l’architecture diffère afin de répondre aux différents modes d’utilisations
possibles.
Ces deux logiciels appartiennent à la gamme Selligent Xi (eXtended
Integration) :
-“Selligent Xi for Windows” qui a un principe de fonctionnement client-
serveur. Il s’agit d’un client lourd, c’est-à-dire qu’il y a un logiciel installé
côté client.
-“Selligent Xi for Web” qui fonctionne avec la technologie Selligent.NET
Server et dont l’architecture est nettement plus complexe (détaillée plus
bas).
Aujourd’hui, tous les efforts de la R&D se portent sur la version Web car la
version Windows ne répond plus aux besoins majeurs du marché de la
CRM qui sont la mobilité, le coût total de propriété (TCO) réduit et le
retour rapide sur investissement (ROI).
La gamme Selligent Xi constitue actuellement la solution GRC la plus riche
du marché mondial en termes de fonctionnalités et de flexibilité.
Une licence Selligent vaut en moyenne entre 1000 et 1500 euros en
fonction du nombre de licences achetées, de la durée de la maintenance,
des fonctionnalités installées, etc.
 Intégration d’un outil de surveillance à un logiciel existant - Logiciel Selligent Xi for Web

2-Logiciel Selligent Xi for Web

2.1-Présentation
Selligent Xi for Web est un logiciel multi utilisateurs, très convivial,
utilisable par un navigateur Web, entièrement sécurisé, ce qui permet une
utilisation à distance.
Ce logiciel est très complet mais il est possible d’ajouter de nombreuses
fonctionnalités en fonction des besoins de chaque entreprise utilisatrice.

2.2-Fonctionnalités CRM
Voici les fonctionnalités CRM offertes par le logiciel :
-informatisation des forces de ventes (itinérantes et/ou sédentaires) :
gestion des processus commerciaux (plannings, publipostage, outils de
prévisions).
-informations marketing :
gestion de campagnes de publicité, identification de profils de
consommateurs, télémarketing, outils d’analyse pour déterminer les
retombées des opérations précédentes.
-gestion des services aux clients :
gestion des garanties et des contrats, du service après-vente, de la
maintenance, des réclamations.

2.3-Technologies utilisées

2.3.1-Architecture DNA et COM

Jusqu'en 2002, la programmation des logiciels Selligent se faisait sous une
architecture de type DNA. Windows DNA (Distributed interNet Applications
Architecture) est un modèle Microsoft de développement d'applications
trois-tiers (présentation-application-données) pour la plate-forme
Windows. DNA spécifie comment développer des applications distribuées,
robustes et évolutives utilisant des composants COM.
COM (Component Object Model) est un modèle de Microsoft qui simplifie
l'intégration de logiciels. Ce standard spécifie comment créer des
composants logiciels indépendants et réutilisables. Tirant parti d'une

Rémy Liscia 9
 Intégration d’un outil de surveillance à un logiciel existant - Logiciel Selligent Xi for Web

orientation objet, COM permet l’encapsulation, le polymorphisme et la

réutilisabilité des composants logiciels dont l'intégration binaire, non
fondée sur le code source, permet de ne pas remettre en cause un logiciel
tout en augmentant les services et fonctionnalités offertes aux
applications. Cette intégration binaire permet aussi d'écrire une
application avec différents langages de programmation. Il s’agissait ici de
C++.
Dans la couche présentation de l'architecture DNA, on trouve les
technologies ASP, JavaScript et XML qui sont chargées de l'interfaçage
avec l'utilisateur.

2.3.2-Architecture .NET
Suite à l’abandon des technologies COM, .NET a été adopté par Selligent.
L’appellation .NET est imprécise car il s’agit en réalité d’un label que
Microsoft attache à plusieurs de ses technologies.
Evoquons les principales :

2.3.2.1-Framework .NET

Avec le framework .NET, Microsoft a bien l’intention d’ouvrir l’ère de la

programmation non plus par assemblage de composants ou d’objets
(COM), mais par réutilisation de services.
Editée en janvier 2002, cette plate-forme est fournie gratuitement par
Microsoft.
Selon Microsoft, le framework .NET est “la nouvelle plate-forme
révolutionnaire, construite sur des protocoles Internet ouverts et des
standards, incluant des outils et des services qui donnent un nouvel
aspect à l'informatique et aux communications”.
Une définition plus compréhensible serait celle-ci : le framework .NET est
un nouvel environnement pour développer et exécuter des applications
 Intégration d’un outil de surveillance à un logiciel existant - Logiciel Selligent Xi for Web

informatiques, fournissant une grande facilité de développement de

services, un ensemble de services pour l'exécution de composants écrits
en une variété de langages de programmation, et une interopérabilité
inter langages et inter machines.
Le framework .NET contient deux composants principaux : la Common
Language Runtime (CLR) et la bibliothèque de classes.
La CLR est un environnement d’exécution (runtime) qui gère le code au
moment de l'exécution, fournit des services essentiels comme la gestion
de la mémoire, la gestion des threads, et l'accès distant. Il applique
également une stricte sécurité des types et d'autres formes d'exactitude
du code qui garantissent un code sécurisé et robuste. En fait, le concept
de gestion de code est un principe fondamental du runtime. Le code qui
cible le runtime porte le nom de code managé.
La bibliothèque de classes est une collection complète orientée objet de
types réutilisables que l’on peut utiliser pour développer des applications
allant des traditionnelles applications à ligne de commande ou à interface
graphique utilisateur jusqu'à des applications qui exploitent les dernières
innovations fournies par ASP.NET, comme les services Web XML et Web
Forms.
Il existe un grand nombre de langages de programmation qui ont été
(re)définis pour fonctionner sur le framework .NET (VB.NET, C#, J# mais
aussi Cobol, Perl, Python, SmallTalk, etc).
Tous ces langages sont compilés sous la forme d’un code binaire
intermédiaire, indépendant du matériel et du système d’exploitation. Ce
langage est ensuite exécuté dans la CLR. Les applications compilées sous
la forme de code intermédiaire se présentent sous la forme de binaires
exécutables portables.
Une conséquence directe du fait que tous les langages du framework .NET
sont compilés sous la forme d’un même code intermédiaire est qu’une
classe écrite dans un langage peut être dérivée dans un autre langage, et
que l’on peut instancier dans un langage un objet d’une classe écrite dans
un autre langage.
Avec .NET, tous les langages offrent en théorie les mêmes possibilités et
fournissent sensiblement les mêmes performances (dans la pratique, tous
les langages ne remplissent pas exactement toutes les spécifications du
 Intégration d’un outil de surveillance à un logiciel existant - Logiciel Selligent Xi for Web

framework .NET), le choix entre les langages est donc effectué en fonction
des goûts et habitudes du développeur, et non plus imposé par des
contraintes d’implémentation.

2.3.2.2-Visual Studio .NET

Visual Studio .NET est un EDI (Environnement de Développement Intégré)

dont le prix varie entre 1000 et 2500 € selon l'édition. Il inclut toute une
gamme de fonctionnalités puissantes et sophistiquées qui permettent de
concevoir, développer, déboguer et déployer des applications robustes,
conviviales et sécurisées.

2.3.2.3-SDK .NET (Software Development Kit)

Il s’agit d’un ensemble de services destinés aux développeurs et fournis

gratuitement. On y trouve des outils tels que des compilateurs en ligne de
commande, ainsi que des exemples et de la documentation.

2.3.2.4-.NET à Selligent

Chez Selligent, les développeurs utilisent l’édition Enterprise Architect de

Microsoft Visual Studio .NET. Ce logiciel leur permet le développement des
éléments en C#, ASP, ASP.NET, JavaScript, VBScript, HTML, CSS, XML et
XSLT mais aussi du code non managé (c'est-à-dire l’ancien code C++).
Le logiciel Selligent Xi for Web tourne sur le framework .NET version 1.0
et la migration vers le framework 1.1 est en cours.

2.3.3-Programmation avec C#
Le langage adopté par Selligent pour la programmation des services .NET
est C#.
Il s’agit d’un langage de programmation conçu par Microsoft. Il est
fortement inspiré de C++ et Java. Microsoft présente C# comme suit :
“C# est un langage de programmation simple, moderne et objet orienté
dérivé de C et de C++. C# est fermement enraciné dans la famille des
langages C et C++. C# vise à combiner la productivité élevée de Visual
Basic et la force brute de C++.”
 Intégration d’un outil de surveillance à un logiciel existant - Logiciel Selligent Xi for Web

2.3.4-Interfaçage avec ASP et ASP.NET

L’interfaçage du logiciel Selligent Xi for Web est réalisé grâce à ASP. La
migration vers ASP.NET devrait être effectuée dans un proche avenir.
ASP (Active Server Pages) est un langage de script Microsoft pour
développer des applications serveur Web dynamiques et interactives : une
page Web ASP affiche un contenu pouvant être différent selon divers
paramètres alors qu'une page Web HTML classique est fixe. C'est un
langage de script interprété du côté du serveur (les scripts CGI, PHP, JSP,
etc, sont aussi exécutés du côté du serveur) et non du côté du client
comme les scripts JavaScript ou les Applets, qui s'exécutent dans le
navigateur.
ASP.NET n'est pas une évolution mais une révolution par rapport à ASP.
Tout d'abord, une page ASP.NET n'est plus un script interprété par le
serveur, mais une dll (fichier binaire) compilée qui sera invoquée par le
serveur, lequel enverra un flux HTML vers le navigateur. Cela permet de
programmer les événements coté serveur en VB.NET ou en C#.

2.3.5-Architecture Selligent .NET

2.3.5.1-Présentation

Fin 2002, les développeurs de Selligent ont migré vers les nouvelles
techniques offertes par le framework .NET de Microsoft. Comme évoqué
plus haut, C++ a été délaissé au profit de C# et ASP.NET va remplacer
ASP. Par contre, il n’est pas à l’ordre du jour de transformer les anciens
composants COM et pages ASP à la technologie .NET, les changements
étant beaucoup trop importants et coûteux.
L’architecture du logiciel Selligent Xi for Web, baptisée en interne Selligent
.NET, est un modèle n-tiers : client, serveur multicouches et données,
dont voici un schéma récapitulatif :
 Intégration d’un outil de surveillance à un logiciel existant - Logiciel Selligent Xi for Web

2.3.5.2-Client

Du côté client, on est dans le cas “zéro client”. Ce terme signifie

qu’aucune application ne doit être installée côté client. Seul un navigateur
Internet Explorer est requis. Il est ainsi possible de se connecter, grâce à
Internet ou à un Réseau Privé Virtuel, au logiciel Selligent Xi for Web
depuis n’importe quel ordinateur (système d’exploitation quelconque) ou
même avec un autre support : téléphone GSM (Wap) ou assistant
 Intégration d’un outil de surveillance à un logiciel existant - Logiciel Selligent Xi for Web

personnel (PDA). Côté client, les technologies mises en oeuvre sont HTML,
CSS, XSLT, JavaScript et VBScript.

2.3.5.3-Serveur

Côté serveur, on distingue les user scripts des business scripts. Les
premiers concernent l’interfaçage utilisateur avec les pages ASP et
ASP.NET hébergées sur un serveur Microsoft IIS. Les business scripts sont
les composants COM et les services .NET utilisés par l’application et
appelés par les pages ASP et ASP.NET. Actuellement, environ 10% des
business scripts sont des services .NET mais cette proportion est appelée
à croître.
Les business scripts peuvent être décomposés en facade, business et data
objects. Les premiers transforment les informations à transmettre aux
user scripts ; les business objects sont chargés des opérations évoluées
du logiciel ; les data objects s’occupent de l’accès et de la récupération
des données.

2.3.5.4-Données

Les données sont stockées dans des bases de données gérées par
Microsoft SQL Server ou Oracle. Les bases de données utilisées par le
logiciel Selligent Xi for Web contiennent un maximum d’informations : en
plus des tables contenant les données “classiques” (tables sur les sociétés,
les accès, les personnes, etc), les bases de données contiennent les
propriétés des champs de formulaires, la mise en forme graphique et
toute autre information personnalisable pour les utilisateurs.
Les queries SQL au moteur de bases de données sont par conséquent très
nombreuses. Or, chaque query a un coût qui n’est pas négligeable. Pour
limiter le nombre de queries, les développeurs de Selligent ont mis au
point deux techniques :
La première, appelée “object pooling”, consiste à récupérer lors du
démarrage de l’application toutes les données lentes à charger et à traiter,
par exemple, les informations concernant l’interface. Cette fonctionnalité
utilise environ 150 queries. Ces données sont chargées une seule fois puis
mémorisées et tous les utilisateurs vont récupérer ces informations
 Intégration d’un outil de surveillance à un logiciel existant - Logiciel Selligent Xi for Web

directement en mémoire. Ainsi, 150 queries sont économisées à chaque

fois qu’une page est chargée par un client Internet Explorer.
La deuxième technique d’économie de queries est la mise en cache.
Lorsqu’un utilisateur récupère des données dans la base, celles-ci sont
gardées en mémoire au cas où un autre utilisateur en aurait
prochainement besoin.

2.3.5.5-Usage du XML

La personnalisation du logiciel par des personnes extérieures à Selligent

exige que les données échangées par chaque composant soient
intelligibles et exploitables par tous.
De plus, le logiciel Selligent Xi for Web peut interagir avec d’autres
applications telles que Microsoft Outlook et Lotus Notes.
La plupart des échanges de données se fait donc au format XML, langage
standard de définition des données, afin d’offrir une interopérabilité
maximale intra et inter applications.

2.3.5.6-Sessions

Le protocole HTTP permet la communication entre un client et un serveur

de la façon suivante :
Le client (c’est-à-dire le navigateur Web) effectue une requête HTTP puis
le serveur trait la requête et envoie une réponse HTTP au client.
L’inconvénient majeur est que cette communication est aussitôt coupée
dès que la réponse a été envoyée par le serveur. Or, dans le cas du
logiciel Selligent Xi for Web, il est important de garder une trace du client
sur le serveur. Grâce à cela, le serveur pourra identifier un client qui
envoie une nouvelle requête et pourra donc associer des objets en
mémoire à un utilisateur spécifique. Le mécanisme qui permet cette
identification du client auprès du serveur est le principe des sessions.
Concrètement, lorsqu’un utilisateur se connecte au logiciel, le serveur lui
attribue un identifiant de session qu’il sauve dans la base de données avec
tous les objets associés à cet utilisateur. Ensuite, lorsqu’un client émet
une requête, il fournit son identifiant de session ce qui permet au serveur
de retrouver l’état de cet utilisateur.
 Intégration d’un outil de surveillance à un logiciel existant - Logiciel Selligent Xi for Web

Ce mécanisme a été entièrement développé par Selligent, car le dispositif

de session proposé par ASP ne convient pas à l’utilisation du logiciel qui
peut être fait en clustering, c’est-à-dire avec plusieurs serveurs.

2.3.5.7-Interopérabilité

En raison de l’utilisation récente des technologies .NET, les développeurs

de Selligent ont dû mettre en oeuvre une communication entre le code C#
et C++. Cette mise en relation, appelée interopérabilité, permet à des
composants COM d’appeler des méthodes .NET et inversement. Le
framework .NET propose des techniques qui facilitent cette
communication.

2.4-Conclusion
Grâce à ces choix techniques, le logiciel Selligent Xi for Web remplit les
critères de qualité suivants : performance, fonctionnalité, flexibilité et
facilité de mise en oeuvre.
 Intégration d’un outil de surveillance à un logiciel existant - Description du projet

3-Description du projet

3.1-Contrat
Selligent a l’habitude de recevoir des stagiaires et leur confie dans tous les
cas un travail réel et pas un cas de programmation d’école qui ne servirait
jamais à autre chose qu’à la soutenance du mémoire de stage.
Il m’a donc été confié un projet nommé en interne “trace”. Ce projet
devait être impérativement terminé à la fin de mon stage car il devait être
intégré à la version 6.10.400 du logiciel mise sur le marché fin juin.
J’ai pu travailler durant tout le stage avec de nombreuses personnes qui
m’ont guidé dans l’analyse et la conception de cet outil.

3.2-Présentation
Le projet qui m’a été attribué durant le stage est la conception d’un outil
de trace. Il s’agit d’une fonctionnalité ajoutée au logiciel Selligent Xi for
Web. Ce composant existe déjà dans le logiciel Selligent Xi for Windows et
son absence dans la version Web mécontentait les clients.

3.3-Fonctionnalités
L'instrumentation de trace permet aux développeurs et aux
administrateurs de surveiller la santé de Selligent Xi for Web fonctionnant
dans des conditions réelles (par opposition à une exécution dans un
débogueur). Parfois, l'utilisation d'un débogueur peut cacher des bogues
et masquer des problèmes de performance et de threads. Le traçage est
un outil de surveillance et de résolution de problèmes très important pour
cette application qui est distribuée multicouches. Les applications de ce
genre contiennent souvent des problèmes que l’on ne peut observer que
lorsque le logiciel est sous une lourde charge et dans les conditions
aléatoires inhérentes à un environnement réel.

3.4-Utilisateurs
En conjuguant des fonctions d’optimisation, de monitoring, d’audit, de
configuration, de détection des anomalies, cet outil répond aux attentes

Rémy Liscia 18
 Intégration d’un outil de surveillance à un logiciel existant - Description du projet

des développeurs de Selligent, du support (assistance), des consultants

chargés de configurer le logiciel dans les entreprises, des administrateurs
réseaux dans les entreprises, etc.

3.5-Fonctionnement détaillé
Le mécanisme de trace récupère les événements (exceptions…) provoqués
par le logiciel ainsi que les queries SQL générées par le logiciel lors des
appels aux bases de données. Toutes ces informations sont triées puis
sauvegardées dans des fichiers.
On distingue deux mécanismes de trace, répondant à des besoins
différents :
-il y a la trace globale qui est lancée par l’administrateur depuis un
outil de configuration. Cette trace récupère toutes les informations
et queries SQL générées par le logiciel, quelques soient les
utilisateurs qui en sont à l’origine (certaines queries sont
anonymes).
-il y a la trace utilisateur qui est soit lancée par l’administrateur
depuis un outil de configuration soit par l’utilisateur lui-même
depuis son interface. Cette trace récupère toutes les informations et
queries SQL générées par l’utilisateur précisé. Ce dernier pourra
afficher dans son interface toute la trace qui a été récupérée.
A terme, ces fonctionnalités seront reprises dans un outil de monitoring
qui effectuera d’autres opérations. Il s’agit donc de concevoir des
composants réutilisables.
 Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

4-Etapes du projet

4.1-Documentation
Lors de mon arrivée, je ne connaissais pas l’entreprise, ni les logiciels
qu’elle publiait. Quelques visites sur leur site Web m’avaient donné une
petite idée de leur activité (la CRM) mais ça restait très flou pour moi. Dès
mon arrivée à Selligent, j’ai donc été informé par plusieurs personnes
(Walter Tricknot, Pascal Evrard) des technologies utilisées, des logiciels
édités et du projet qui allait m’être confié.
En plus de plusieurs réunions d’information, j’ai dû pousser mes
connaissances par moi-même en me documentant sur divers ouvrages
(anglophones). Cette documentation consista d’abord par l’étude des
fonctionnalités des logiciels de Selligent (fonctions CRM), des technologies
utilisées par ces logiciels (COM, DNA, .NET), de l’architecture complexe du
logiciel Selligent Xi for Web et enfin par l’apprentissage du langage C# qui
était nécessaire pour les développements ultérieurs.
Souvent ennuyeuse et harassante, je tire tout de même un bilan positif de
cette période de documentation. L’apprentissage de toutes ces
technologies m’a énormément apporté, au même titre qu’un
enseignement à l’IUT. La bonne maîtrise (ou au moins la compréhension)
de ces techniques s’est révélée payante pour la suite. J’ai vraiment eu le
sentiment d’avoir appris des concepts très importants dans l’informatique
d’aujourd’hui.
Quant à l’étude d’un nouveau langage de programmation, je
l’appréhendais grandement. A tort car C# est un langage proche de C++
que je maîtrisais bien et de Java dont j’avais eu une initiation à l’IUT. La
syntaxe et les mécanismes du langage ne me posèrent donc pas beaucoup
de problèmes, à l’inverse des concepts propres au framework .NET
(remoting, services Web, graphisme, etc) que je laissais finalement de
côté.
Il m’a fallu deux semaines pour me mettre au niveau que l’on me
demandait.

Rémy Liscia 20
 Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

4.2-Analyse
L’analyse était un passage obligé dans ce projet que j’appréhendais
énormément en raison de l’aperçu que j’en ai eu à l’IUT. J’ai vite changé
d’opinion.
L’équipe des quatre analystes est fortement liée aux développeurs. Ils
prennent des décisions techniques et fonctionnelles ensemble par le biais
de très fréquentes réunions.
Walter Tricknot et Jenny Migliore m’ont encadré pour l’analyse du projet
de trace. Ils m’ont d’abord présenté leur travail, avec l’appui de nombreux
exemples. Ils utilisent comme méthode d’analyse OMT (Object Modeling
Technique) qui est antérieure à UML mais tout de même orientée objet.
Malgré son universalité, ils reprochent à UML de ne proposer qu’une
syntaxe, sans aucune méthode d’analyse clairement spécifiée. Les
méthodes existantes basées sur UML ne répondent pas aux besoins de
Selligent : Rational Rose et d’autres méthodologies basées sur UML ont
été testées par le passé mais aucune ne s’est révélée satisfaisante. Ces
méthodes, très complètes, prenaient énormément de temps et la
rédaction des documents d’analyse finissait par être plus longue que le
développement à proprement parler.
C’est pourquoi Selligent a adopté OMT qui permet de couvrir l'ensemble
des processus d'analyse et de conception en utilisant le même formalisme.
L'analyse repose sur trois points de vue : statique, dynamique et
fonctionnel.
En pratique, il m’a d’abord fallu rédiger un document texte qui énonçait
les besoins liés à ce projet (cf. documents d’analyse en annexe).
La modélisation statique qui suivait consistait à identifier et à documenter
les classes au format texte. Ensuite, il a fallu réaliser un diagramme de
classes reprenant ces informations et qui présente l’ensemble des classes
du système d’information et des liaisons entre ces classes.
Les diagrammes sont réalisés à Selligent grâce à Visio, produit Microsoft
de la suite Office qui fournit des outils visuels.
La modélisation dynamique est composée des principaux scénarios de
séquences au format texte et sous la forme de diagrammes. Il s’agit là
d’identifier toutes les principales séquences d’événements. Les
 Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

diagrammes d’état composent également la modélisation dynamique et

consistent à représenter tous les états possibles de chaque objet (ou
classe) du système.
Enfin, la modélisation fonctionnelle présente sous la forme de texte et de
diagrammes les principales fonctions d’entrées-sorties et d’interface.
A chaque fois que je passais au modèle suivant, Walter Tricknot et Jenny
Migliore validaient mon travail et me donnaient des pistes pour continuer.
Ce contrôle régulier m’a permis de ne pas partir sur une mauvaise voie
dès le début.
De plus, il m’a naturellement fallu tout au long de l’analyse garder un
regard critique sur ce que j’avais fait au préalable afin de corriger
d’éventuelles erreurs ou imprécisions.
L’analyse, qui a duré deux semaines, a été ponctuée de nombreuses
réunions avec diverses personnes afin de déterminer au mieux les besoins
du projet ; ces réunions ont beaucoup influé sur la réalisation des
documents d’analyse.
A l’issue de cette période d’analyse, il est apparu une contrainte
imprévue : en plus du développement des classes et des fonctions
déterminées par l’analyse, il faudrait effectuer un grand nombre de
modifications au sein du logiciel Selligent Xi for Web car ce dernier est
bien entendu lié au mécanisme de trace. Pascal Evrard, le développeur qui
devait coordonner mes travaux a pris ces modifications à sa charge.
En ayant côtoyé des analystes durant plusieurs semaines, la conclusion
que j’en retire est qu’il existe indéniablement deux sortes d’analystes : il y
a d’abord les analystes informaticiens qui chercheront la meilleure solution
technique à un besoin et qui se concentreront principalement sur cet
aspect technologique. Il y a aussi les analystes qui ne prennent en compte
aucune contrainte technique mais qui expriment le besoin et développent
cet aspect là. Alors que les uns ont une approche beaucoup plus
technique, les autres sont dans une optique orientée fonctionnelle et
utilisateur final.
Cette distinction est clairement établie au sein de Selligent. Les uns
comme les autres jouent un rôle primordial et complémentaire. Mais selon
les dires de Monsieur Téchy, directeur technique, “l’analyste idéal, la perle
rare, est celui qui parvient à travailler avec ces différents points de vue”.
 Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

4.3-Développement

4.3.1-Langage et environnement
Depuis quelques mois, tous les nouveaux développements de Selligent
sont effectués en C#. Le passage à ce langage ne s’est pas fait sans âpres
discussions. Pour ma part, je n’ai vu que des avantages à C#. J’ai
vraiment eu le sentiment d’utiliser un langage de programmation plus
clair, plus intuitif, moins complexe que C++, que j’avais appris à l’IUT.
Cela dit, à de plus hauts niveaux de programmation, certains
développeurs de Selligent affirment que C++ était un langage bien plus
puissant. Voici leurs arguments :
-L’héritage multiple de classes, permis en C++, n’est pas autorisé en C#.
-Les pointeurs sont automatiques en C#. Leur utilisation est masquée, ce
qui a pour conséquence que l’on ne se rend pas toujours compte de ce
que l’on fait.
-Autre absence dans C# : les templates (patrons) qui apportaient
beaucoup de puissance.
-La copie de code dans le fichier binaire (mot-clé include) n’a pas
d’équivalent en C#. Elle est remplacée par l’ajout de références.
-On trouve en Visual C++ des macros, absentes en C#.
Revoici ces arguments discutés par les adeptes de C# à Selligent :
L’impossibilité en C# d’utiliser l’héritage multiple, de manipuler les
pointeurs encourage une programmation plus intuitive et un code plus
lisible. Le remplacement de la copie de code par l’ajout de référence réduit
la redondance de code binaire et allège les fichiers dll et exe.
Le problème des templates peut être contourné par la dérivation entre
plusieurs dll. Les macros sont des lourdeurs évitables impossibles à
déboguer.
De plus, il existe une multitude de types en C++ (par exemple, 20 types
pour des chaînes de caractères en C++ contre 2 en C#) ce qui rend le
code encore plus opaque.
En outre, pour utiliser COM, il a été ajouté à C++ une couche ATL qui
imposait beaucoup de limitations et qui ne permettait donc pas au final
d’exploiter au mieux C++.
 Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

Ils concluent en affirmant que C# contraint le développeur à une

programmation plus rigoureuse ce qui a pour résultat un code plus lisible,
plus intuitive, moins sale ; alors que C++, par sa puissance, est une
véritable “usine à gaz”, ils espèrent résoudre leurs problèmes passés (par
exemple la gestion de la mémoire) avec C#.
L’adoption de C# par Selligent étant entérinée, les premiers bilans font
état d’un triplement de la productivité au niveau du développement.
Un autre débat, antérieur, fut celui de l’adoption des technologies de
Microsoft .NET. En effet, des plateformes Java comme J2EE ou Jbuilder
sont apparues sur le marché à peu près en même temps que les
solutions .NET de Microsoft. Les qualités des environnements Java sont
nombreuses mais le choix de Selligent pour Microsoft est justifié par les
raisons suivantes : les entreprises clientes de Selligent utilisent
principalement les technologies Microsoft ; de plus, les technologies
utilisées auparavant par Selligent étaient des produits Microsoft (DNA,
COM, etc) ; enfin, les solides garanties d’une entreprise comme Microsoft
ont été préférées à l’esprit communautaire des technologies Java.

4.3.2-Implémentation des classes

Il existe d’excellents générateurs de code qui créent du code source à
partir des documents d’analyse. Ils présentent les avantages suivants :
respect des spécifications du référentiel, qualité constante, délais connus,
pas de surcoût.
Cependant, Selligent n’utilise pas ce genre d’outils pour les raisons
suivantes :
Ces outils sont très efficaces dans le cas de développement de logiciels sur
mesure, pour du RAD (Rapid Application Development). Dans le cadre des
logiciels de Selligent, on observe une “optimisation à outrance” du code.
Chaque développeur doit faire évoluer le logiciel en modifiant ce qui
existe, il a “les mains dans le cambouis”. S’il devait se plonger dans du
code généré automatiquement, son travail deviendrait colossal. De plus,
on ne saurait utiliser un générateur de code pour venir ajouter des
fonctionnalités au logiciel. Par ailleurs, un générateur de code efficace
exige des documents d’analyse très complets, ce qui n’est pas le cas chez
Selligent. Enfin, les générateurs de code ne sont pas adaptés à des
 Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

architectures multicouches, ils ne savent générer à la fois du visuel et des

objets programmés.
J’ai donc commencé par traduire l’analyse en écrivant les classes
principales, puis en complétant le code des fonctions au fur et à mesure.
J’ai également créé un programme de test sous la forme d’un formulaire
Windows, très simple à mettre en oeuvre grâce à Visual Studio .NET.
Cette partie de la programmation fut très rapide (quelques jours) pour
plusieurs raisons :
-après plusieurs semaines de théorie, je passais à la pratique en goûtant
enfin à ce langage C#, ma motivation était donc sans limite.
-par ailleurs, toutes les notions de programmation requises pour
implémenter les classes et les fonctions principales étaient plutôt simples
et similaires à la programmation effectuée à l’IUT.
J’ai donc implémenté les classes principales, effectué des tests pour
vérifier que la communication entre ces classes s’effectuait correctement.
Naturellement, ma production n’était pas encore reliée au logiciel et
n’était nullement dans les conditions réelles. Le programme de test
proposait la saisie des informations qu’il faudrait recevoir du logiciel plus
tard et lançait le mécanisme de trace pour ces informations.
Un débat survint alors entre les analystes et les développeurs : fallait-il
transmettre les résultats de la trace sous forme de fichiers textes simples
ou au format XML ?
La première réponse fut d’aller dans le sens du XML. En effet, ce méta
standard est exploitable par tout programme et un futur outil de
monitoring aurait ainsi pu récupérer ces données aisément.
Cependant, gérer le XML n’est pas chose simple. En plus de la gestion de
caractères spéciaux, il fallait veiller à respecter la mise en forme propre au
XML (deux balises racines qui limitent tout le document). Cela augurait de
multiples opérations sur les données à sauver et sur le fichier. Il était
évident que persister la trace dans un simple fichier texte à considérer
comme un journal d’événements était plus aisé. Finalement, le XML fut
choisi car il était nécessaire de pouvoir récupérer les données afin de les
mettre en forme pour les afficher ultérieurement. Quant aux opérations
qui s’annonçaient délicates, je les contournai grâce à l’utilisation
 Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

pertinente de classes du framework .NET de manipulation XML et de

fichiers.
En parallèle à la réalisation des nouvelles classes de trace, il fallait,
comme cela avait été déterminé dans l’analyse, modifier le logiciel
existant pour que la trace récupère toutes les queries et événements.
Cette modification du code (principalement du C++) a été effectuée par
Pascal Evrard. Il m’a présenté à plusieurs reprises l’étendue de cette tâche
extrêmement rébarbative en raison des kilomètres de code à vérifier et de
l’imbroglio propre au C++.

4.3.3-Intégration dans le logiciel

C’est à ce niveau que la programmation est devenue plus complexe et que
ma productivité a fortement chuté.
Il a d’abord fallu connecter les classes que j’avais développées avec le
logiciel que Pascal Evrard avait mis à jour. Etant donné que ces classes
étaient pour la plupart des composants COM écrits en C++ et que mon
application de trace était en C# géré par le framework .NET, il a fallu
mettre en oeuvre une interopérabilité .NET/COM : en effet, les
composants COM du logiciel devaient appeler et envoyer les messages de
trace aux méthodes C# que j’avais développées.
Pour mettre en place l’interopérabilité dans ce sens (de COM vers .NET), il
faut agir de la manière suivante : les objets .NET sont accessibles à COM
au travers d'un Wrapper (“emballage” en français) nommé COM Callable
Wrapper. Ce Wrapper transforme l'interface .NET exposée par la classe C#
en interface compatible COM. A noter que pour qu'un composant COM
puisse voir un objet .NET, celui-ci doit être enregistré dans la base de
registres (c’est automatique). Pour tester, il suffisait à présent d’exécuter
le logiciel et de constater le résultat dans les fichiers XML générés.
On m’a alors demandé de développer un service qui permettait de gérer la
trace grâce à du “remoting asynchrone”.
Le remoting consistait ici à diviser l’application de trace en deux processus
distincts à l’image du modèle client-serveur. On fait tourner le serveur en
arrière-plan et on instancie un canal de communication. Lorsque le logiciel
envoie un message à tracer, un client est créé et transfère le message sur
 Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

le serveur grâce au canal de communication précité. L’objet sur le serveur

se charge alors de la sauvegarde au format XML.
Concernant la communication interprocessus, il a fallu faire un choix entre
les protocoles de communication HTTP et TCP. Le protocole HTTP a pour
avantage d’être le plus souple car il peut passer au travers des proxies et
des firewalls car il transporte les données au format SOAP (texte). Mais ce
format (SOAP est dérivé de XML) est relativement lourd. Le protocole TCP
est quant à lui plus léger (transformation binaire). En revanche, le
passage par des firewalls ou des proxies n’est pas garanti. Etant donné
que le mécanisme de trace sera sur une seule machine (deux au
maximum), nous avons opté pour une
communication TCP.
L’asynchronité permet de traiter la trace
sans ralentir le logiciel. En effet, dans un
environnement de production réel, il se
peut que le mécanisme de trace soit
ralenti pour une raison quelconque ; il ne
faut surtout pas que le logiciel en soit
affecté. Mieux vaut saturer la trace que
ralentir toute l’application. C’est pour
cela que l’envoi des messages vers le
serveur de trace se fait de façon
asynchrone c'est-à-dire sans attendre la
fin de la sauvegarde dans le fichier.
La mise en place du remoting asynchrone
a fait appel aux notions de sérialisation,
de thread, de delegate, etc.
Dans l’ensemble, on peut dire que le
framework .NET apporte beaucoup de
solutions simples à des problèmes très
complexes. Par exemple, le remoting est
un mécanisme extrêmement compliqué, qui aurait pris énormément de
temps avec du code C++. Grâce à quelques classes du framework
correctement utilisées, le puissant mécanisme se met en route avec
seulement quelques lignes de code. En fait, la complexité du
 Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

framework .NET réside seulement dans la connaissance et la

compréhension des services fournis.
C’est alors que survinrent quelques soucis. L’environnement de
développement que j’utilisais, Visual Studio .NET, s’est mis à fonctionner
aléatoirement, perturbant sérieusement l’avancée de mon travail. Cela
s’est exprimé par des exceptions systèmes qui se déclenchaient par
moments, par le débogueur qui ne montrait aucune de ces anomalies, par
des erreurs de gestion de mémoire, par des défaillances dans
l’interopérabilité, par une fermeture anticipée du serveur de trace, etc. Je
me mis à maudire cet environnement jusqu’à ce que Pascal Evrard vérifie
mon code et découvre que je déclarai un objet du service, je désactivai
ensuite le service puis appelai une méthode sur l’objet supprimé au
préalable. Alors que je me demandais pourquoi il y avait des problèmes,
j’aurais dû me demander pourquoi ça marchait parfois. Cette mésaventure
a mis en évidence la “garbage collection”, c’est-à-dire la libération de la
mémoire effectuée par la CLR du framework et qui ne libère pas la
mémoire de façon instantanée ce qui me permettait parfois d’appeler
l’objet lorsque le garbage collector n’était pas encore intervenu.
Une fois que ça a marché, j’ai dû intégrer la trace dans le logiciel Selligent
Xi for Web. Cela s’est traduit d’abord par l’intégration de l’objet Trace à un
des composants binaires déjà existants (c’est-à-dire à une des dll utilisées
par le logiciel). J’ai ensuite défini le service de trace parmi les services
Windows accessibles depuis la Microsoft Management Console, outil qui
permet de visualiser, démarrer ou arrêter les services définis (on y trouve
le serveur IIS, la messagerie MSN Messenger, les connexions réseaux,
etc).
J’ai pu alors tester une nouvelle fois la trace dans des conditions quasi-
réelles.

4.3.4-Interface utilisateur
J’ai ensuite eu l’opportunité de découvrir le côté visuel du logiciel.
Selligent Xi for Web possède un outil de configuration accessible, comme
le reste de l’application, depuis un navigateur Web. Il me fallait procéder à
une modification de certaines pages de cet outil de configuration afin que
la trace puisse être activée, désactivée et configurée depuis cet outil. J’ai
 Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

donc eu accès aux sources de cette partie de l’application. A l’inverse de

mes développements précédents où j’avais travaillé sur des codes sources
en local, en toute tranquillité, je travaillais maintenant sur des codes
sources partagés. Je n’avais pas le droit à l’erreur, car si j’effectuai une
mauvaise manipulation, c’était toute l’équipe de R&D qui était pénalisée.
J’y suis donc allé avec des pincettes, manipulant précautionneusement des
pages ASP et XSLT. J’ajoutai donc mes éléments visuels dans le code
HTML, puis reliai les évènements (par exemple activation ou changement
du numéro de port TCP) au service de trace ou à la base de registres.
J’avais étudié le langage PHP à l’IUT, qui est, comme l’ASP, un langage de
programmation côté serveur. Alors que le PHP ressemblait énormément
au langage C, l’ASP m’a semblé très proche du Visual Basic.
Concernant l’utilisation de cette trace, il reste à insérer les mécanismes
d’affichage des messages de trace dans l’interface utilisateur pour que la
trace soit tout à fait opérationnelle. Ce domaine (l’interface utilisateur du
logiciel) est le domaine réservé de quelques informaticiens de Selligent qui
avaient d’autres priorités à ce moment. Cela est cependant moins
primordial car la trace est sauvée au format texte XML et est donc
présente dans des fichiers sur le serveur (récupérables par
l’administrateur). J’ignore à ce jour si je serai impliqué dans ces
développements.
La période de développement a duré cinq semaines.

4.4-Tests
Tout au long du développement, je faisais subir à mon application toutes
sortes de tests. Cependant, durant la plus grande partie du
développement, seules les classes de démarrage du logiciel envoyaient
des messages au mécanisme de trace ; bien que ces classes envoient
jusqu’à 12 messages par seconde pendant quelques secondes (surtout des
queries SQL) et que la trace fonctionnait sans problème, je ne peux
prétendre avoir testé la trace dans des conditions réelles d’utilisation.
J’aurais peut-être l’occasion de réaliser des tests plus sérieux avant la fin
du stage.
Il faut cependant savoir que seuls les tests unitaires et d’intégration sont
à la charge des développeurs de Selligent, étant donné qu’un département
 Intégration d’un outil de surveillance à un logiciel existant - Etapes du projet

de l’entreprise composé de quatre informaticiens est chargé du contrôle

qualité c'est-à-dire des tests finaux.
Les tests unitaires consistent à tester toutes les éventualités pour chacun
des objets, séparément, à l’inverse des tests d’intégration qui permettent
d’évaluer la robustesse de l’objet replacé (intégré) dans l’application.

4.5-Récapitulatif
Avec en moyenne deux réunions hebdomadaires avec l’informaticien qui
supervisait mon stage (analyste ou développeur), je pouvais avancer
efficacement en pouvant rectifier le tir si je partais dans la mauvaise
direction. C’était aussi l’occasion pour moi de demander plus
d’informations sur les concepts complexes que j’avais eu à affronter.
J’ai également assisté à quelques réunions de toute l’équipe de R&D qui
m’ont fait apparaître comment une vingtaine d’informaticiens parviennent
à travailler ensemble.
Les dix semaines du stage se sont réparties ainsi :
Deux semaines de documentation, deux semaines d’analyse et cinq
semaines de développement, avec très souvent des interactions entre les
trois : la documentation n’a pas cessé durant le développement et
l’analyse a été peaufinée tout au long du projet.
La dernière semaine du stage verra probablement la finalisation du projet
 Intégration d’un outil de surveillance à un logiciel existant - Le bilan du stage

5-Le bilan du stage

5.1-Bilan du projet
Au tout début du stage, lorsque j’ai réalisé l’étendue de ce qui
m’attendait, en plus du “simple” développement de mon projet, à savoir la
compréhension des technologies mises en oeuvre et que j’aurais à utiliser,
je fus effrayé car cela me paraissait aussi indigeste qu’impossible à
assimiler par soi-même en si peu de temps. Puis vinrent la lecture des
ouvrages et les explications promulguées par les informaticiens de
Selligent. Là, la documentation ne fut pas vraiment source d’ennuis mais
avais-je bien compris tous ces concepts ? Enfin, le développement me fit
apparaître les lacunes que j’avais, les points de la documentation que
j’avais négligés ou mal interprétés et je dus donc me replonger dans les
livres.
Les conclusions que je tire de cette auto apprentissage sont que le plus
important est de ne pas hésiter à affronter la complexité, quitte à
questionner ensuite le maître de stage ou un professeur ou encore à aller
chercher des compléments d’information sur Internet. Savoir affronter
l’inconnu pour le maîtriser me semble primordial dans ce métier.
En outre, la réalisation du projet m’a apporté de nouvelles connaissances
techniques. Il me semble que, sans pour autant les maîtriser totalement,
ma compréhension du principe des technologies .NET de Microsoft est un
atout majeur car il s’agit vraisemblablement de méthodes de
développement d’avenir.
Enfin, la conduite d’un projet concret et dont la finalité est d’être utilisée
dans des cas de production réels est extrêmement motivant et valorisant.

5.2-Un stage à l’étranger

Vivre 10 semaines dans un pays étranger pour travailler ne peut être
comparé ni à des vacances, ni à un stage “à domicile”.
La Belgique est un pays proche de la France, que ce soit
géographiquement ou culturellement. En raison des nombreux points
communs entre ces deux pays, je n’eus aucune difficulté à m’intégrer dès

Rémy Liscia 31
 Intégration d’un outil de surveillance à un logiciel existant - Le bilan du stage

le début dans la vie quotidienne. Les plus grands désagréments furent la

médiocre qualité de la baguette de pain belge et le fait que le 8 mai ne
soit pas un jour férié, c’est dire ! Quant aux apports positifs, je peux
aujourd’hui me vanter de connaître ce pays, ses habitudes, ses gens, etc.
J’en retire beaucoup de maturité et je pense que si j’ai l’opportunité de
faire un autre stage dans les années à venir, je chercherai à le réaliser
dans un milieu encore plus “hostile” (langue, culture, mentalités
différentes).
En outre, ce stage a eu un aspect linguistique : d'une part la Belgique est
nettement plus ouverte sur l’étranger que la France et d'autre part, j’étais
dans une entreprise multinationale.
En effet, bien que Charleroi soit en région Wallonne (francophone), mes
progrès en anglais ont été immenses. Car avec trois langues officielles, les
belges francophones ne sont pas attachés comme en France à la pérennité
de la francophonie. Ainsi, de nombreux termes anglais sont préférés au
français au quotidien. Alors dans le secteur informatique, qui plus est dans
une entreprise vouée à l’export, la langue anglaise est omniprésente,
certains employés de Selligent allant jusqu’à communiquer entre eux en
anglais. Et naturellement, tous les ouvrages techniques qui ont été mis à
ma disposition étaient dans la langue de Shakespeare. Ce fut donc une
surprise immense mais pas vraiment désagréable : s’il m’avait fallu
maîtriser le néerlandais (la langue belge des affaires), j’aurais été
sérieusement ennuyé…

5.3-Un stage en entreprise

N’ayant jamais travaillé dans une société de cet acabit, l’expérience a été
nouvelle pour moi. J’en retiens beaucoup d’enseignements : comme dans
une fourmilière, chacun à sa fonction bien déterminée, la coordination
entre chacun par les dirigeants n’a lieu que très rarement car les
employés font preuve de beaucoup d’autonomie et d’initiative. Je pense
avoir eu aussi beaucoup de chance car j’ai été reçu dans une entreprise
qui alliait avec succès sérieux et bien-être des employés, ce qui m’a
vraiment impressionné dans une société de cette importance. Ainsi, les
horaires sont totalement libres, les locaux accessibles 24h/24, avec de
nombreux espaces de détente (cafétéria, ping-pong, salon…), dans un
 Intégration d’un outil de surveillance à un logiciel existant - Le bilan du stage

cadre agréable (bâtiment rutilant au sein d’un technopôle, plantes vertes

dans les locaux, grandes baies vitrées, distributeurs de boissons…) en
échange d’un travail rigoureux. Ce contexte de confiance est pour
beaucoup dans la bonne humeur qui règne dans les bureaux et qui est
fortement stimulante pour travailler.
Cela dit, comme dans toute entreprise, il y a une hiérarchie bien définie,
des délais, des réunions, du stress, des désaccords, des conflits. Ayant eu
sur tout cela une vision de l’intérieur, j’en tire beaucoup de leçons sur les
relations patron employés et entre employés, sur le travail, sur le monde
de l’entreprise…

5.4-Un stage de fin d’études

Après un an et demi d’études en IUT informatique qui est une formation à
vocation professionnelle, ce stage de deux mois et demi a été l’occasion
de mettre en application toute la théorie vue à Rodez. Cependant, ce
stage apporte beaucoup de recul : avoir eu de bons résultats à l’IUT
n’implique pas forcément une réussite sur le plan professionnel, si chacun
ne fournit pas l’effort nécessaire en temps voulu pour répondre au mieux
à ce que l’on attend de lui.
En fait, l’IUT, en plus d’offrir de solides bases d’un point de vue technique,
nous prépare au monde du travail en nous apportant les réflexes qu’un
informaticien doit avoir acquis (rigueur, autonomie, dynamisme,
relationnel, motivation). Quant au stage, il apporte le recul nécessaire
pour comprendre tout cela.
Ce stage m’apparaît comme indispensable et est une conclusion parfaite à
ce cycle d’études.
C’est une excellente introduction au monde du travail. Et pour ceux,
comme moi, qui souhaitent poursuivre leurs études, ce stage permet
d’aborder de nouveau l’enseignement avec un regard totalement différent
et une approche beaucoup plus positive (avec par exemple une curiosité
accrue et plus de recul).
 Intégration d’un outil de surveillance à un logiciel existant - Annexes

Annexes

Glossaire
ASP et ASP.NET (Active Server Pages)
Langages Microsoft de programmation Web qui proposent une
dynamicité côté serveur et qui permettent de créer de puissantes
applications Internet.
C# (prononcer “see sharp”)
Langage de programmation récent (certifié ISO en avril 2003) créé
par Microsoft pour son framework .NET. Il reprend les points positifs
de C++ et de Java.
C++
Langage de programmation conçu en 1982 qui reprend le langage C
en y ajoutant principalement les possibilités de la programmation
“orientée objet”.
COM (Component Object Model)
Modèle d’objets et ensemble de règles programmatiques,
permettant aux objets (composants) d’interagir les uns avec les
autres par le truchement d’interfaces. On parle de norme binaire à
propos de COM car cette spécification concerne la réutilisation du
code machine.
CRM ou GRC (Customer Relationship Management, en français : Gestion
de la Relation Clientèle)
Ensemble de méthodes qui permettent aux entreprises de mettre
en avant les relations qu’elles ont avec leurs clients, relations axées
sur le cycle prospection, vente, maintenance et relance.
DNA (Distributed interNet Applications Architecture)
Architecture tripartie basée sur COM et destinée à faciliter la
création d’applications Windows distribuées.
IIS (Internet Information Server)
Serveur (de Microsoft) réseau ou Web de fichiers et d’applications,
compatible avec de nombreux protocoles.

Rémy Liscia 34
 Intégration d’un outil de surveillance à un logiciel existant - Annexes

Interopérabilité
Capacité des applications, des composants… à coopérer en se
passant des données, en appelant les méthodes des uns ou des
autres, etc.
Logiciel à base de composants
Logiciel dont les fonctionnalités sont réparties sur une multitude de
composants COM capables d’interagir.
OMT (Object Modeling Technique)
Méthode d’analyse orientée objet qui a pour principal atout
d’indiquer clairement la marche à suivre.
Query SQL (en français : requête SQL)
Opération qui consiste à extraire d'une table (d'une base de
données) tout ou partie des éléments qui s'y trouvent.
R&D (Recherche et Développement)
Dans le cas d’une entreprise informatique, département chargé de
la recherche et de l’exploitation de nouvelles technologies, ainsi que
de la production logicielle.
Selligent
Société basée à Gosselies près de Charleroi (Belgique), éditeur de
logiciels de CRM.
Selligent.NET
Technologie serveur mise en oeuvre pour le logiciel Selligent Xi for
Web, basée sur les technologies ASP.NET et C#.
Selligent Xi
Gamme de produits logiciels commercialisés par Selligent.
Comprend une version Windows et une version Web.
Selligent Xi for Web
Produit phare de Selligent. Basé sur une architecture distribuée à
client léger. La version 7.0 est prévue pour l’été 2003.
SOAP (Simple Object Access Protocol)
Protocole d’échange d’information dans un environnement distribué.
Il est basé sur XML.
SQL (Structured Query Language)
Langage de définition, de manipulation et de contrôle des données
utilisé pour les bases de données relationnelles.
 Intégration d’un outil de surveillance à un logiciel existant - Annexes

SQL Server
Système de gestion de bases de données de Microsoft.
UML (Unified Modeling Language)
Notation permettant de modéliser un problème de façon standard.
XML (eXtensible Markup Language)
Langage standard de description des données (alors que HTML est
un langage de représentation des données).
XSLT (eXtensible Stylesheet Language Transformations)
Langage de transformation de documents XML en autres documents
(de type XML, HTML, texte, RTF, etc).

Bibliographie

Ouvrages
Designing for scalability with Microsoft Windows DNA (Microsoft
programming series – Sten and Per Sundblad)
Au coeur de COM+ (Microsoft press – Guy et Henry Eddon)
C# and the .NET Platform (Apress – Andrew Troelsen)
OMT – Modélisation et conception orientée objet (Masson – James
Rumbaugh)
OOP in .NET (U2U - Win Uyttersprot)
Advanced .NET Remoting (Apress – Ingo Rammer)

Documents numériques
MSDN for Visual Studio.NET et http://msdn.microsoft.com
http://www.selligent.com et documentation à usage interne
http://www.bvamyfra.fr
http://www.dotnet-fr.org
http://dotnet.developpez.com
http://www.dotnetguru.org
 Intégration d’un outil de surveillance à un logiciel existant - Annexes

Chronologie du stage
Lundi 14 avril 2003 avec Walter Tricknot : présentation des logiciels
Selligent Xi, des architectures.
Début de la documentation
Jeudi 17 avril 2003 avec Walter Tricknot, Jenny Migliore, Laurent De
Greef pour faire le point sur mes travaux de documentation et pour
discuter du projet SQLTrace ; Cette réunion fait apparaître que l’idée de
départ concernant le projet ne pourra être réalisée car l’architecture du
logiciel “Selligent Xi for Web” ne le permet pas (il est possible d’identifier
le client (côté client) et de tracer les requêtes SQL (côté base de données)
mais cela risque d’être trop lourd par rapport à l’application).
Mardi 22 avril 2003 avec Walter Tricknot, Laurent De Greef, Pascal
Evrard, Paula Gonzaga de Sa, Jenny Migliore : réévaluation du projet
SQLTrace et prises de décisions techniques et fonctionnelles: SQLTrace
devient Trace (fonctions étendues).
Mercredi 23 avril 2003 avec Pascal Evrard pour une explication détaillée
de la réunion de la veille.
Vendredi 25 avril 2003 avec Pascal Evrard pour définir le projet d’un
point de vue et mettre en évidence les questions importantes.
Lundi 28 avril 2003 avec toute l’équipe R&D (22 personnes) pour une
réunion de mise au point globale au retour de congés du directeur du
département R&D.
Lundi 28 avril 2003 avec Walter Tricknot et Jenny Migliore pour parler
analyse : ils m’ont présenté leur méthode d’analyse, il s’agit d’OMT, une
méthode antérieure à UML mais qu’ils préfèrent car elle indique plus
clairement la marche à suivre.
Début de l’analyse
Mardi 6 mai 2003 avec Walter Tricknot, Jenny Migliore et Pascal Evrard
pour faire le point sur l’analyse et affiner le projet.
Vendredi 9 mai 2003 avec Pascal Evrard pour déterminer comment
débuter la programmation.
Début de la programmation
Lundi 12 mai 2003 : appel de l’IUT représenté par Monsieur Barrios.
 Intégration d’un outil de surveillance à un logiciel existant - Annexes

Puis réunions bihebdomadaires (en moyenne) pour faire le point sur la

programmation.
Mercredi 4 juin 2003 avec Frédéric Loesch pour commencer la
programmation visuelle.
Mercredi 11 juin 2003 : envoi du présent mémoire à l’IUT.

Documents produits lors de l’analyse du projet

Voir page suivante

Brochure de publicité
Voir dernière page
 Projet Trace – Analyse
Étape 1 : énoncé

LE BESOIN GLOBAL
Trop souvent, les développeurs de Selligent perdent du temps en essayant en
vain de localiser l’origine d’anomalies ; il en est de même pour le help desk qui
doit souvent essayer de comprendre des problèmes, exposés à distance,
rencontrés par des utilisateurs ou des intégrateurs ; les administrateurs de
systèmes sur lesquels le logiciel Selligent ne fonctionne pas parfaitement (par
exemple : ralentissement du système) ne parviennent pas à déterminer
précisément l’origine de cette anomalie ; ces mêmes administrateurs qui
souhaitent effectuer des contrôles (de sécurité) ou des statistiques d’utilisation
n’en ont pas les moyens ; les consultants chargés de configurer et de
personnaliser le logiciel chez le client souhaitent connaître la localisation des
informations dans la base de données, l’ordre d’exécution, le principe de
fonctionnement… Actuellement, aucun outil ne répond aux attentes de tous ces
acteurs primordiaux et dont le logiciel Selligent ne saurait se passer.
Il convient donc d’élaborer un outil qui puisse améliorer les conditions de travail
de tous.
Ainsi, cet outil devra faciliter l’optimisation de l’application, le monitoring, l’audit,
la configuration, la détection et la résolution des anomalies.

ANALYSE DETAILLEE DU BESOIN

“Trop souvent, les développeurs de Selligent perdent du temps en essayant en
vain de localiser l’origine d’anomalies”
Cet outil leur permettra de récupérer les exceptions et les évènements propagés
par le logiciel. D’autres informations, comme le plan d’exécution, leur seront
fournies afin de mettre en évidence l’origine de l’évènement.
“il en est de même pour le help desk qui doit souvent essayer de comprendre des
problèmes, exposés à distance, rencontrés par des utilisateurs”
Afin de ne plus perdre de temps dans la compréhension du problème, le help desk
se verra transmettre par l’utilisateur un fichier contenant les messages générés
par le logiciel. Le traitement de l’anomalie en sera facilité.
“les administrateurs de systèmes sur lesquels le logiciel Selligent ne fonctionne
pas parfaitement (par exemple : ralentissement du système) ne parviennent pas
à déterminer précisément l’origine de cette anomalie”

Analyse – page 39
Souvent, de simples queries à la base de données suffisent à ralentir de manière
conséquente toute l’application. Il est donc nécessaire de pouvoir connaître
quelles sont les queries SQL les plus lourdes.
“ces mêmes administrateurs qui souhaitent effectuer des contrôles (de sécurité)
ou des statistiques d’utilisation n’en ont pas les moyens”
De multiples opérations d’audit peuvent être décidées par les administrateurs ; il
peut s’agir de contrôles de sécurité (par exemple : déterminer les tentatives de
connexion échouées afin de savoir s’il y a des essais de piratage), ou de
statistiques par exemple : savoir qui se connecte le plus).
“les consultants chargés de configurer et de personnaliser le logiciel chez le client
souhaitent connaître la localisation des informations dans la base de données,
l’ordre d’exécution, le principe de fonctionnement”
La personnalisation du logiciel passe parfois par l’ajout de nouveaux composants.
La conception de ces composants est effectuée par des personnes externes à
l’équipe de R&D (des consultants, des intégrateurs) qui n’ont pas forcément une
juste représentation des aspects techniques du logiciel. Il faut donc leur fournir
une idée de la localisation des données en affichant les queries SQL.

Ce mécanisme de trace devra être intégré au logiciel Selligent Xi for Web.

Il pourra être mis en route par l’administrateur ou par l’utilisateur, selon les cas.
En plus de proposer un affichage via l’interface du logiciel, on pourra récupérer
les résultats au format texte dans des fichiers, afin de les transmettre par email
au help desk par exemple.
Différencions les cas d’utilisation :
Un utilisateur qui rencontre un problème dans sa session pourra activer une trace
qui récupérera tous les évènements générés par l’utilisation du logiciel par cette
personne. Les queries SQL liées à cet utilisateur seront également récupérées.
L’activation de la trace sera une option accessible depuis le menu de Selligent Xi
for Web.
Durant toute la période où la trace sera activée, il faudra qu’un indicateur le
rappelle via une icône sur l’interface du logiciel.
Cette trace cessera de fonctionner lorsque l’utilisateur demandera l’affichage de la
trace via le menu ou lorsqu’il fermera sa session.
L’affichage de la trace se fera dans une fenêtre Web pop up qui permettra de faire
défiler l’ensemble des informations récupérées par la trace.
Ces informations seront également accessibles sur le serveur par un fichier au
format texte.

Analyse – page 40
Lorsque la trace sera lancée, il ne sera plus possible d’afficher les informations de
la précédente trace.
L’administrateur pourra lancer la trace d’un utilisateur via la config du logiciel, en
cochant simplement une option pour cet utilisateur.
A ce moment, et durant toute la période où la trace sera active, l’utilisateur sera
prévenu qu’il est “tracé” grâce à une icône sur l’interface du logiciel.
Lorsque l’utilisateur se déconnectera, sa trace restera quand même à l’état actif.
La trace de cet utilisateur sera accessible et visualisable via le fichier texte
présent sur le serveur.
L’administrateur pourra de plus activer une trace globale, par l’intermédiaire de la
config. Cette trace récupèrera tous les évènements et toutes les queries SQL.
Cela permettra de récupérer aussi les queries anonymes, c’est-à-dire celles qui
servent lors du démarrage de l’application à charger les informations partagées
(pool) par tous les utilisateurs.
Le seul moyen de désactiver la trace sera de repasser par la config. Ainsi, la
fermeture du logiciel ne désactivera pas la trace et celle-ci sera de nouveau active
dès le redémarrage du logiciel.
Là aussi, la visualisation de la trace se fera directement par l’accès au fichier
texte généré sur le serveur.

Analyse – page 41
 Projet Trace – Analyse
Étape 2 : modélisation statique

IDENTIFICATION DES CLASSES

Les classes C++ existantes RecordsetContainer et CommandContainer sont
reliées à une classe C++ TraceFilter qui juge la pertinence de chaque message et
le propage ou non. Cette classe, ainsi que les classes C# existantes TableReader
et TableWriter sont reliées à la classe statique Trace. Celle-ci peut implémenter
un objet de type TraceMessage ou une des classes qui en dérivent : TraceQuery
ou TraceEvent.
La classe Trace accède ensuite à la classe TraceWriter.

DICTIONNAIRE DES DONNEES

Voici le dictionnaire des données :
TraceMessage Information récupérée du logiciel
Selligent Xi for Web
TraceQuery Type de message qui correspond à une
query SQL
TraceEvent Type de message qui correspond à un
évènement propagé par le logiciel
Trace Ensemble ordonné de messages
spécifiques à un utilisateur ou global à
tout le logiciel
TableReader et TableWriter, Services .NET (C#) et composants COM
RecordsetContainer et (C++) existants dans le logiciel
CommandContainer Selligent Xi for Web qui permettent
l’accès aux bases de données (lecture,
écriture, modification et suppression de
données)

Analyse – page 42
 Projet Trace – Analyse
Étape 3 : modélisation dynamique

SCENARIOS DE SEQUENCES TYPIQUES

1- Lancement de la Trace utilisateur par l’utilisateur lui-même ou par
l’administrateur
L’activation de la Trace par l’utilisateur provoque un changement de l’état
en mémoire de cet utilisateur.
L’activation de la Trace via la config provoque un changement dans la base
de données de l’état de cet utilisateur.
Lorsque RecordsetContainer (ou CommandContainer, TableReader,
TableWriter) constate un changement, il transmet l’information (création
d’une nouvelle Trace utilisateur) au composant qui crée une nouvelle
instance de Trace.
Celle-ci transmet ses informations au service qui, lui aussi crée une
instance de Trace.
2 – Lancement de la Trace globale
L’activation de la Trace via la config provoque un changement de l’état
d'un paramètre dans la base de registres. Lorsque RecordsetContainer (ou
CommandContainer, TableReader, TableWriter) constate un changement,
il transmet l’information (création d’une nouvelle Trace globale) au
composant qui crée une nouvelle instance de Trace.
Celle-ci transmet ses informations au service qui, lui aussi crée une
instance de Trace.
3 – Enregistrement d’un message pour une Trace utilisateur
RecordsetContainer (ou CommandContainer, TableReader, TableWriter)
vérifie si une Trace est active pour l’utilisateur indiqué par le message ; le
cas échéant, le message est transmis à la Trace en question dans le
composant.
Celui-ci vérifie la pertinence du message. Si le message est validé, il est
transmis à la Trace correspondante dans le service de manière
asynchrone.
La Trace instanciée dans le service écrit le message dans le fichier
(création du fichier s’il n’existe pas).
4 – Enregistrement d’un message pour une Trace globale

Analyse – page 44
 RecordsetContainer (ou CommandContainer, TableReader, TableWriter)
vérifie si une Trace globale est active ; le cas échéant, le message est
transmis à la Trace en question dans le composant.
Celui-ci vérifie la pertinence du message. Si le message est validé, il est
transmis à la Trace correspondante dans le service de manière
asynchrone.
La Trace instanciée dans le service écrit le message dans le fichier
(création du fichier s’il n’existe pas).
5 – Désactivation d’une Trace
Lorsque l’état en mémoire ou dans la base de registres concernant la
Trace est désactivé, RecordsetContainer (ou CommandContainer,
TableReader, TableWriter) envoie un message au composant qui désactive
la Trace en question.
Celle-ci transmet au service un message de désactivation.
Le service désactive cette Trace.

Analyse – page 45
Analyse – page 46
Analyse – page 47
Analyse – page 48
 Projet Trace – Analyse
Étape 4 : modélisation fonctionnelle

CREER UNE TRACE

En entrée
L’acteur RecordsetContainer (ou autre…) fournit le type de trace et l’utilisateur.
Opérations
Vérifier que la trace demandée est bien inactive
Créer la trace
En sortie
L’acteur trace est instancié

CREER UN MESSAGE
En entrée
L’acteur RecordsetContainer (ou autre…) fournit l’utilisateur.
Opérations
Vérifier que la trace est active
Créer un message
En sortie
L’acteur message est instancié

ENVOYER UN MESSAGE
En entrée
L’acteur message fournit tous ses attributs
Opérations
Sérialiser le message
Envoi asynchrone du message par remoting
En sortie
Néant

ECRIRE UN MESSAGE
En entrée
Le texte qui correspond au message sérialisé
Opérations
Écriture dans le fichier
En sortie

Analyse – page 49
Néant

Analyse – page 50