1

Rapport de stage

Effectué à :

Du 8 février 2010 au 23 avril 2010

TECHSIA 340 rue Louis Pasteur 34790 Grabels

Par Jonathan Tremesaygues

Directeur de stage de l'entreprise : Directeur de stage de l'université : Ronan MENEU Geneviève SIMONET

Amélioration

du TestServer

Confidentiel

2

Remerciements Avant de commencer ce rapport, je tiens tout d’abord à remercier l'ensemble des personnes qui ont

rendu mon stage possible et qui ont contribué à son bon déroulement.

Ronan Meneu, mon maître de stage et Aurélien Billard pour m’avoir intégré dans l’équipe TechData,

pour leur disponibilité, leur soutien, leurs conseils et pour m’avoir apporté un suivi régulier dans mon

travail.

L’équipe TechData pour m’avoir encadré avec attention.

L'ensemble des développeurs pour leur implication, l’intérêt qu’ils m’ont apporté et le temps qu’ils

m’ont accordé.

Je remercie également toutes les personnes que j’ai pu côtoyer dans l’entreprise pour leur accueil et

leur sympathie.

3

Table des matières Remerciements ....................................................................................................................................... 2

Introduction ............................................................................................................................................. 5

Connaissance de l'entreprise .................................................................................................................. 6

Contexte .............................................................................................................................................. 6

La société Schlumberger ..................................................................................................................... 6

La société Techsia ................................................................................................................................ 7

Présentation et situation géographique ......................................................................................... 7

Secteurs d'activité et positionnement ............................................................................................ 9

Savoir-faire ...................................................................................................................................... 9

Organisation interne ....................................................................................................................... 9

Les produits ................................................................................................................................... 11

La prestation de services ............................................................................................................... 11

Les logiciels .................................................................................................................................... 11

Outils et TestServer ............................................................................................................................... 14

Outils utilisés ..................................................................................................................................... 14

Komodo Edit .................................................................................................................................. 14

WampServer .................................................................................................................................. 15

SQLyog Community ....................................................................................................................... 15

Tortoise SVN .................................................................................................................................. 16

TestServer .......................................................................................................................................... 17

Qu’est-ce que le TestServer ? ........................................................................................................ 17

A quoi sert-il ?................................................................................................................................ 17

Comment fonctionne-t-il ? ............................................................................................................ 17

Présentation détaillée ................................................................................................................... 17

Travail effectué ...................................................................................................................................... 22

Optimisation des performances ........................................................................................................ 22

Au début était SQLite… .................................................................................................................. 22

…Puis vînt MySQL .......................................................................................................................... 22

Résultat .......................................................................................................................................... 22

Ajout de fonctionnalités .................................................................................................................... 23

Global Result.................................................................................................................................. 23

Summary........................................................................................................................................ 23

Dynamic Result .............................................................................................................................. 23

4

Test description ............................................................................................................................. 24

Keywords ....................................................................................................................................... 25

Graphiques ........................................................................................................................................ 25

Travail demandé ............................................................................................................................ 25

Choix de la technologie ................................................................................................................. 25

Réalisation ..................................................................................................................................... 26

Conclusion ............................................................................................................................................. 27

Annexe ................................................................................................................................................... 28

Script de migration de SQLite à MySQL ............................................................................................. 28

Script de mise à jour des descriptions des tests ............................................................................... 30

5

Introduction

Afin de valider la dernière année de mon DUT Informatique, j’ai effectué un stage d’une durée de 11 semaines dans la société Techsia implantée à Grabels, située proche de Montpellier. Lors de ma recherche de stage, mon objectif était de trouver un stage en informatique et plus particulièrement un sujet me permettant de faire du développement WEB. Je voulais profiter de ce stage pour accroître rapidement mes compétences avant d’arriver sur le marché de l’emploi. Parmi les différentes offres de stage, j’ai accepté l’offre que proposait la société Techsia car durant l’entretien j’ai compris que ce stage me permettrait de réaliser un travail varié, intéressant et utile au sein de l’entreprise. Le premier objectif de ce stage était de mettre en pratique les connaissances techniques que j’avais pu acquérir au cours de ma formation. En effet, j’ai suivi beaucoup de cours théoriques que je n’avais pas encore pu appliquer à des situations concrètes. Le second objectif était de me confronter au monde de l’entreprise et à son mode de fonctionnement afin de préparer mon insertion dans le monde professionnel. La première phase du stage fût de me familiariser avec le personnel de l’entreprise et avec les outils utilisés. La seconde fût d’améliorer les performances du TestServer. J’ai ensuite travaillé sur l’ajout de nouvelles fonctionnalités au TestServer. Enfin, j’ai réalisé un système de reporting*. Dans ce rapport, je vais commencer par présenter l’entreprise puis le travail que j’ai effectué et enfin mon bilan personnel.

6

Connaissance de l'entreprise

Contexte

Avant de se lancer dans l'exploitation d'un champ pétrolifère, les compagnies pétrolières ont besoin

de caractériser précisément le sous-sol et les fluides contenus dans le gisement. Les enjeux sont

considérables car des moyens techniques et financiers de grande envergure doivent être déployés en

cas de découverte d’un gisement. La société Techsia est née du besoin accru des compagnies

pétrolières en matière de précision et de quantification en vue d'une prise de décision optimale.

La société Schlumberger

La société Schlumberger a racheté au mois de juin 2009 l'intégralité des actions de Techsia SA qui

deviendra le « Schlumberger Petrophysics Software Center of Excellence ». Schlumberger est la plus

grande société multinationale de services pétroliers. En effet elle compte plus de 80 000 employés de

140 nationalités dans plus de 80 pays à travers le monde. Elle fut fondée en 1926 par les frères

Conrad et Marcel Schlumberger dans le nord de la France grâce à leurs idées innovantes pour

détecter différents types de roches par conductivité électrique. La société est désormais installée aux

Antilles néerlandaises, mais ses principaux bureaux sont situés à Houston, Paris et La Haye, avec un

centre de Recherche & Développement à Clamart. Le groupe dispose de partenariats avec diverses

universités et a créé plusieurs centres de formation interne accueillant 1200 personnes par jour. En

2008, hors forage, environ 10% de l'effectif sont consacrés aux géosciences (géologues,

géophysiciens et ingénieurs de réservoirs).

La société Schlumberger est cotée à la Bourse de Paris et à la Bourse de New York. Schlumberger a

pâti en 2009 de la crise économique et de la baisse des cours du brut. Le groupe accuse une baisse de

16% de son chiffre d’affaires sur l'ensemble de l’année dernière, à 22,70 milliards de dollars, et un

repli encore plus important de son bénéfice net, (-41%) à 3,16 milliards.

La société est dirigée par Andrew Gould et elle se décompose en plusieurs services et produits.

Techsia est intégrée dans le service Schlumberger Information Solutions (SIS) qui est une unité

opérationnelle fournissant des logiciels, la gestion de l'information, l'infra- structure et les services

pour résoudre les problèmes des sociétés gazières et pétrolières.

7

La société Techsia

Présentation et situation géographique

Techsia est une société qui fut créée le 25 octobre 2000. Stéphanie Gottlib-Zeh, Docteur en

Géophysique et Présidente Directrice Générale de la société, est à l'origine de cette création. C'est au

cours de sa thèse réalisée à TotalFina Elf qu'elle ressent le besoin, pour les domaines des

Géosciences, d'une entreprise comme Techsia. Le projet initial a ainsi été lauréat, deux années

consécutives (1999 et 2000), du concours national d'aide à la création d'entreprise de technologies

innovantes. Le siège social de Techsia est situé sur la colline de Grabels, dans le parc Euromédecine,

aux portes de Montpellier. Techsia possède également deux filiales, une à Houston aux Etats Unis et

l'autre au Sultanat d'Oman. La société est leader technique et bientôt commerciale sur le logiciel

Techlog. L'effectif de la société est de cinquante salariés pour une moyenne d'âge de 31 ans. Pour sa

première année d'activité (2001), Techsia a réalisé un chiffre d'affaires de 323 000 euros. En 2008, il

s'élève à près de 9,06 millions d'euros et son capital est de 579 947,06 d’euros. Le détail du

personnel ainsi que le poste de chaque personne est représenté dans l'organigramme de la page

suivante.

8

Figure 1 : ORGANIGRAMME DE LA SOCIETE TECHSIA

9

Secteurs d'activité et positionnement

L'activité de Techsia se positionne dans les domaines des technologies innovantes, et plus

précisément dans la chaîne du traitement et de l'analyse des données acquises dans les puits de

forage. Techsia est à la fois éditeur de logiciels et prestataire de services (études). Ses méthodes

s'appliquent au traitement de données volumineuses et/ou hétérogènes, dans le domaine des

géosciences (géophysique, géologie, gisement) en général, et de l'interprétation des données de

forage/sondage (géologiques, pétro-physiques, diagraphiques* et géophysiques) en particulier. Elle

travaille également dans le domaine des procédés (analyse multiple de fluides complexes :

thermodynamique appliquée GC/MS).

Savoir-faire

Le savoir-faire de Techsia découle de 9 années de recherche et développement qui lui ont permis de

mettre au point des méthodes et des outils innovants destinés à améliorer l'interprétation de

données géologiques. A ce jour plusieurs compagnies pétrolières internationales exploitent ces

méthodes dans le but de mieux caractériser leurs réservoirs pétroliers. Techsia possède donc trois

métiers principaux :

- La pétro-physique : traitement et interprétation des données (diagraphiques* et carottes)

acquises au puits.

- La géophysique : traitement et interprétation des données sismiques.

- Les procédés : analyse des fluides complexes.

Ces trois métiers reposent essentiellement sur un apport informatique considérable grâce aux

compétences de Techsia dans le développement de logiciels performants et adaptés aux besoins de

ses clients.

Organisation interne

Outre son aspect technique, Techsia fait également preuve d'une organisation innovante en

regroupant en interne trois pôles de compétences complémentaires en interaction permanente:

10

Compétences Métiers

Techsia regroupe des ingénieurs « métiers » dans les domaines des Géosciences (géophysique, pétro-

physique, sédimentologie, thermodynamique et analyse physico- chimique). Ces compétences «

métiers » leur permettent d'appréhender au plus juste les besoins du client. Leur expertise repose à

la fois sur leur haut niveau de qualification et sur leur culture du monde industriel, développée

pendant leur parcours. Autour de ces compétences métiers s'articulent les compétences statistiques

et informatiques.

Compétences Statistiques et Numériques

Le savoir-faire de Techsia repose sur les méthodes statistiques et numériques les plus récentes, telles

que les réseaux de neurones, l'optimisation paramétrique de systèmes complexes non linéaires, les

plans d'expériences ou les méthodes de Monte-Carlo.

Ces compétences sont entièrement dédiées à la résolution de problématiques "métiers".

Compétences Informatiques

L'équipe d'informaticiens de Techsia assure l'optimisation des algorithmes et la mise au point de

logiciels scientifiques précis et performants adaptés aux besoins de ses clients. Ces trois

compétences se regroupent dans une organisation structurelle originale, schématisée sur la figure

suivante.

Figure 2 : ORGANISATION STRUCTURELLE

Ce type d'organisation offre un double avantage :

- La garantie de produits de qualité,

- La rapidité et la facilité de communication entre les compétences.

11

Les produits

Deux activités principales caractérisent Techsia : - La prestation de services et la conception, - Le développement de logiciels issus de travaux de recherches et de développements

internes.

La prestation de services

Techsia propose une prestation de services qui se traduit par des études utiles pour les géosciences. Ces études sont de deux types :

- Des études traditionnelles classiques réalisées en pétro-physique.

Des études de recherches et de développements visant à optimiser les méthodes de calcul et d'interprétation Deux activités principales caractérisent Techsia :

- La prestation de services et la conception, - Le développement de logiciels issus de travaux de recherches et de développements

internes.

Techsia propose une prestation de services qui se traduit par des études utiles pour les géosciences. Ces études sont de deux types :

- Des études traditionnelles classiques réalisées en pétro-physique. - Des études de recherches et de développements visant à optimiser les méthodes de calcul et

d'interprétation - du client dans ses domaines d'activités.

Ces études sont principalement réalisées pour le compte de plusieurs clients tels que TotalFina Elf, Gaz de France et l'Andra, mais aussi des clients anglo-saxons tels qu'Amerada Hess (USA), BHP Billiton (AUSTRALIE), Burlington Resources (Canada), British Petroleum (UK), Marathon Oil, Phillips. . .

Les logiciels

Techlog

Techlog est un logiciel de géosciences pour l'interprétation géologique des diagraphies*. C'est un

outil qui permet une exploitation différente et optimisée des informations contenues dans les

enregistrements diagraphiques*, c'est à dire des signaux captés par les sondes généralement

descendues dans les forages pétroliers, afin de déterminer à distance, via des paramètres physiques,

la nature du sous-sol. Le calibrage de ces données est effectué par l'étude des carottes échantillons

de roches prélevées (à grands frais) dans les parties des réservoirs des couches géologiques

traversées, dont on corrèle la description géologique avec les réponses électriques des diagraphies*.

Techlog constitue une aide à la modélisation et s'utilise en parallèle avec les logiciels classiques

d'interprétations géologiques. Une panoplie complète d'outils statistiques intégrés (utilisés dans une

chaîne logique optimisée) permet une amélioration de la séquence de travail.

12

Il optimise le lien entre le modèle géologique statique (vision interprétée de l'architecture du sous-

sol : œuvre du géologue) et le modèle réservoir dynamique (vision déduite de l'écoulement des

fluides dans les couches productives des réservoirs d'hydrocarbures, estimation de la production :

œuvre de l'ingénieur réservoir).

Grâce à l'utilisation intégrée de plusieurs modules, le géologue peut fournir des informations

quantifiées à l'ingénieur réservoir qui peut évaluer plus précisément la production pétrolière :

- TechCore : Solution ultime pour l'interprétation et l'intégration des données « carottes ». - Qcfield : Module dédié au traitement et à l'édition d'une grande quantité de données puits. - Quanti : Alternative intelligente à l'interprétation conventionnelle des diagraphies* (multi-

puits, multizones). - Quanti.min : Résolution de problèmes inverses. - K.mod : Reconstruction objective de données manquantes. - Ipsom : Classification des électro-faciès et prédiction des faciès lithologiques. - BHI : Application d'imagerie dédiée au traitement et à l'interprétation de la résistivité, de

l'acoustique et de la densité dans les puits. - Geophi : Solution combinant des données pétro-physique et géologique. - CoreDB : Base de données pour un stockage et une gestion efficace de tous les types de

données carottes. Tous ces modules reposent sur un noyau que l'on peut diviser en 3 parties :

- Techplot : Large panel d'outils interactifs appliqués à l'affichage de diagraphies* et de données carottes.

- Techdata : o Traitement et transmission des données o Base de données simple et efficace o Importation et exportation des données o Edition des données

- Techstat : o Outils statistiques classiques o Série d'applications statistiques multi-variables*

Le groupe chargé du développement de Techlog est divisé en plusieurs équipes que l'on retrouve dans l'organigramme page 4 :

- R&D : Responsable de la partie recherche et développement au sein de Techlog. - TechPetro : Responsable de la partie métier au sein de Techlog. - TechPlot : Responsable de la partie visualisation (2D et 3D) au sein de Techlog. - TechData : Responsable de la partie donnée au sein de Techlog.

13

Figure 3 : Aperçu du logiciel Techlog

Malcom

Malcom est un logiciel qui propose des solutions innovantes pour répondre à des problèmes

critiques du monde pétrolier actuel, tant dans la maîtrise des procédés que dans la prospection. Un

enjeu important de la prospection pétrolière est de déterminer la connectivité des réservoirs de

pétrole. C'est-à-dire de déterminer dans quelle mesure la réserve de pétrole à un endroit donné est

scindée en réservoirs distincts. Plus la connectivité des réservoirs seront importante, plus l'extraction

sera aisée et efficace. En effet, moins il y a de réservoirs distincts, moins le nombre de forages

nécessaires est important. La connectivité peut être déduite grâce à la comparaison de la

composition chimique de plusieurs fluides extraits dans un périmètre restreint. Il est évident que plus

la composition de deux fluides sera proche, plus leur chance d'appartenir à un réservoir unique est

grande. Le principal but de Malcom est donc d'aider à la détermination de la composition chimique

des fluides complexes (dont fait partie le pétrole). Pour cela, il utilise la Chromatographie en phase

Gazeuses. Mais ces résultats, bien trop complexes, ne sont pas directement exploitables. Il faut donc

analyser ces données pour en retirer l'information pertinente.

14

Outils et TestServer

Outils utilisés

Pendant toute la durée du stage, j'ai eu à disposition toutes sortes d'outils qui m'ont permis de

mener à bien les tâches qui m'ont été confiées. Voici une brève description des principaux outils que

j'ai utilisés.

Komodo Edit

Komodo Edit est un éditeur de texte multiplateformes* et open source basé sur Active State

Komodo IDE. Il est dédié aux langages interprétés tels que PHP, Python, Ruby et aux langages

orientés « web » tels que JavaScript, html, css. Il supporte en outre de manière native de nombreuses

librairies AJAX (JQuery, Prototype, dolo…), et possède une très bonne auto-complétion.

Figure 4 : Capture d'écran de Komodo Edit

15

WampServer

WampServer est une plateforme de développement Web de type WAMP, permettant de faire

fonctionner localement des scripts PHP. WampServer n'est pas en soi un logiciel, mais un

environnement comprenant deux serveurs (Apache et MySQL), un interpréteur de script (PHP), ainsi

qu'une administration pour les deux bases SQL PhpMyAdmin et SQLiteManager.

Il dispose d'une interface d'administration permettant de gérer et d'administrer ses serveurs au

travers d'un tray icon (icône près de l'horloge de Windows).

SQLyog Community

SQLyog est un programme permettant de gérer une base de données MySQL. Il dispose d’outils

permettant de synchroniser des données manuellement ou automatiquement et d’avoir un aperçu

des documents. Il permet de naviguer entre les données et d’effectuer de multiples requêtes. Avec

ce logiciel, il est possible de gérer une ou plusieurs bases de données à la fois et de personnaliser les

tables et les champs de la base de données selon ses besoins. Il autorise également à importer des

données ODBC et de gérer l’hôte MySQL à sa guise. SQLyog donne la possibilité d’exporter des

données au format CSV, XML, HTML ou Excel.

Figure 5 : Capture d'écran de SQLyog Community

16

Tortoise SVN

Afin de gérer des projets en commun de manière à ce que chaque utilisateur puisse travailler sur une

copie du projet à partir de son poste de travail, nous utilisons SVN. SVN est un outil de versionning

open source. Il permet de tracer les modifications des développeurs et la date de leur réalisation, et

permet ainsi de revenir en arrière en cas de problème. Il permet également de fusionner des

fonctionnalités entre plusieurs développeurs. Comme CVS, SVN est l'outil le plus utilisé lors des

développements collaboratifs. Il permet d'éviter les conflits entre différentes versions d'un même

fichier. En étant sûr d'avoir une version compilée qui fonctionne sans erreur à l'exécution, le

développeur peut faire une mise à jour du projet par rapport à la version se trouvant sur le réseau.

De plus, lorsqu'une modification est incomprise par un membre de l'équipe il sait à qui demander

une explication.

17

TestServer

Qu’est-ce que le TestServer ?

Le TestServer est un système développé et utilisé en interne par Techsia. Il est composé d’un site internet et d’un client* écrit en Python*.

A quoi sert-il ?

Malcom et Techlog sont de gros logiciel, où une erreur de programmation peut facilement se glisser

et avoir des conséquences dramatiques tel qu’un crash du logiciel ou une erreur de calcul, qui pour

cette dernière peut avoir des répercussions sur l’analyse des données, et entrainer de mauvaises

décisions pour les entreprises qui les utilisent. Le TestServer permet de tester automatiquement les

logiciels afin de détecter leurs erreurs ou faire des tests de performance pour vérifier que les

nouvelles versions n’entrainent pas de régressions. Il dispose aussi de fonctionnalités permettant de

visionner les résultats des tests, d’un système de reporting* sous forme de graphiques…

Comment fonctionne-t-il ?

L’opérateur ajoute tout d’abord la nouvelle version du logiciel dans le TestServer, puis choisit les

tests à exécuter. A partir de là, les ordinateurs de tests vont automatiquement récupérer la version

concernée du logiciel, l’installer, récupérer la liste de tests, les exécuter et enfin poster les résultats

sur le TestServer.

Présentation détaillée

Global Result

C’est la page principale du TestServer. Elle affiche les résultats des tests pour les versions

sélectionnées. Elle possède 2 modes d’affichages, le premier dit « Normal » permet de visualiser les

erreurs selon le code couleur suivant :

- Vert (Ok) : réussite du test

- Orange (Fail) : le test à correctement était exécuté, mais a retourné une valeur incorrecte

- Rouge (Error) : le test ne n’est pas arrivé jusqu’à la fin

- Jaune : combinaison de vert et d’orange et/ou de rouge : le test a été correctement exécuté

sur certains ordinateurs mais a échoué sur d’autre

- Bleu (Perffail) : le test a été correctement exécuté, mais a été inhabituellement long

18

Figure 6 : Page "Global Result" en mode « Normal »

Le second mode appelé « Perf Color » permet de comparer visuellement les performances d’un test : plus le temps d’exécution du test s’éloigne de son meilleur temps, plus son pourcentage augmente

(selon la formule

), et donc plus la couleur s’obscurcie. Les tests trop courts

(moins de 2 secondes) ne sont pas comptabilisés.

Figure 7 : Page "Global Result" en mode "Perf Color"

19

Summary

La page « Summary » permet de visualiser toutes les erreurs d’une version. Cette page est surtout utilisée en début de journée, après une nuit de tests pour réaliser le planning de la journée.

Figure 8 : La page "Summary"

Result

La page Result permet de voir les derniers résultats des tests postés.

Figure 9 : La page Result

20

Test Pipe

La page « Test Pipe » permet de voir quel sont les prochains tests à être jouer, et modifier leurs

ordres.

Figure 10 : La page "Test Pipe"

Add Test

La page « Add Test » permet d’ajouter des tests dans le pipe (la file d’attente des tests).

Figure 11 : page Add Test

21

Graphiques

La page graphique permet d’accéder à divers graphiques sur les performances des tests ou sur les

statistiques du TestServer.

Figure 12 : Page Graphiques, graphiques sur l'ajout de tests et sur leur consommation de temps

Administration

La partie Administration contient des outils pour administrer le TestServer. On peut entre autre y

insérer des tests, y ajouter des produits, gérer les ordinateurs de tests…

Figure 13 : Page d'administration des ordinateurs

22

Travail effectué

Optimisation des performances

Au début était SQLite…

L’une de mes premières tâches fût d’optimiser les performances du TestServer.

Originellement, il était basé sur le système de gestion de base de données (SGBD) SQLite qui

présente l’avantage de ne pas utiliser de serveur : la base de données est enregistrée dans un fichier,

ce qui permet de faciliter certaine des tâches de maintenance tel que la sauvegarde : il suffit de

copier le fichier ailleurs. Mais au cours du temps énormément de données ont été ajoutés à la base

de données, atteignant une taille de presque 1Go (l’équivalent de 830 disquettes !), et plus de 4

millions d’enregistrement pour la table de résultat des tests. L'ampleur des données additionnés aux

nombreux accès concurrents à la base de données qui assurent le postage ou le visionnage de

résultats occasionnaient de nombreux ralentissement, voir même des "times-out"(la base ne

répondais plus aux requêtes).

…Puis vînt MySQL

La solution choisit afin de palier à ce défaut fût de migrer à MySQL, un SGBD Open Source des plus

utilisés, autant par le grand publique (essentiellement pour des applications web) que par les

professionnels (tel que Facebook et Skyrock, deux ténors des réseaux sociaux occasionnant plusieurs

millions de visiteurs par jours).

La migration du site web

La migration du site web fut relativement aisée, car le TestServer utilise PDO, une bibliothèque du

langage PHP qui permet d’offrir une couche d’abstraction aux bases de données : il suffit

théoriquement de remplacer la ligne de connexion pour que cela fasse effet. Le passage de la théorie

à la pratique n’est jamais sans soucis, et ce n’est pas cette fois qui en sera l’exception… En effet,

SQLite et MySQL n’utilise pas exactement la même syntaxe du langage SQL*, un nombre conséquent

de requêtes durent être corrigées voir même entièrement réécrites. Mais ce travail fût moins

laborieux que si le TestServer avait été écrit en utilisant la bibliothèque native de SQLite : dans ce

cas-là, tous les appels à des fonctions de SQLite auraient dû être réécrits.

La migration des données

La seconde étape fut de migrer les données de SQLite vers MySQL. Le principal problème venant du

fait qu’il n’existait aucune solution gratuite permettant de transférer un tel volume de données de

manière automatique et satisfaisante. Pour répondre à cette problématique, j’ai écrit un petit script

en langage Python que vous trouverez en annexe. Son fonctionnement est assez simple : selon les

paramètres renseignés, il génère des requêtes de sélections, SQLite les exécutes, récupère les

données, crées les requêtes d’insertions MySQL et les exécutent. Grâce à ce script, la migration du

TestServer « SQLite » au TestServer « MySQL » a pu se faire avec une interruption de service de

l’ordre de la demi-heure. L’interruption était nécessaire pour garder la cohérence du système.

Résultat

Comme le montre le tableau suivant, la migration de SQLite à MySQL à permit un gain notable dans

la réactivité du TestServer, les pages se chargent plus rapidement. La disparition des

23

«times outs » et autres files d’attentes à la base de données, a beaucoup amélioré le passage des

tests. En effet les ordinateurs de tests attendent moins longtemps pour recevoir leur prochain test,

et il n’y plus d’erreur lors du postage des résultats. Le gain de temps est d’autant plus considérable

qu’il permet ainsi d’éviter de rejouer certains tests inutilement, sachant que certain mettent

plusieurs heures à s’exécuter.

Page/action Temps d’affichage SQLite Temps d’affichage MySQL Gain de temps

GlobalResult 2min 49s 15s 1min 34s (96%)

Static Result 2.5s 1.1s 1.4s (56%)

Remonter 4 tests dans le pipe

> 5min 7s

Figure 14 : Résultat benchmark

Note : les valeurs proviennent de mon ordinateur de test, les temps d’exécution ne reflètent pas la

réalité, par exemple, la page Global Result en MySQL prend en réalité moins de 5s pour s’afficher.

Ajout de fonctionnalités

A la demande des utilisateurs, de nombreuses fonctionnalités ont été ajoutées au TestServer. Je vous

propose d’en résumer quelques une ici.

Global Result

Le plus gros travail sur cette page fut d’ajouter le mode « Perf Color » qui permet de visualiser les

performances des tests. De plus il a eu une refonte de la page dans le but d’améliorer son

ergonomie.

Summary

Cette page fut ma première tâche sur le TestServer. En effet, malgré les nombreux outils présents, il

n’existait pas de moyen simple pour avoir une vision globale de toutes les erreurs d’une version.

Dynamic Result

Cette page a été créée dans le but de remplacer la page « Static Result », qui se contentait de lister

les 1000 derniers résultats. La nouvelle page permet d’interagir avec les données, permettant de

faire des tris et des filtres. J’ai utilisé la fonctionnalité « LiveGrid » bibliothèque JavaScript OpenRico

et j’ai modifié cette dernière dans le but d’ajouter des fonctionnalités manquantes, telle que la

possibilité de surligner de diverses couleurs des lignes répondant à certains critères. J’ai fait part de

mes modifications à l’auteur de la bibliothèque, qui les intégrera peut-être dans une future version.

24

Figure 15 : Affichage des erreurs pour le testcase "TechlogBHITestCase"

Test description

Un système permettant de voir la description des tests a été ajouté. Il est composé d’une note de

javascript pour l’affichage de la description.

Figure 16 : Une description de test

La description des tests est présente dans les tests. Un script python s’occupe d’insérer

automatiquement la nouvelle description des tests dans la base de données lors de la modification

de ceux-ci. Vous trouverez ce script en annexe.

25

Keywords

Il s’agit de l’ajout d’un système permettant de trier les tests par un système de keyword.

Figure 17 : sélecteur de keywords dans la page « Global Result »

Graphiques

Travail demandé

Le développement de cette partie était le plus attendu par l’entreprise, mais malheureusement après

les nombreuses tâches que j’ai dû effectuer au préalable, ce ne fut que vers la fin de mon stage que

je pus m’y mettre. Par la suite le temps manquant désespérément, je ne pus finir mon travail avant

de terminer le stage.

Il m’a donc été demandé de faire une série de graphiques permettant de se faire une idée visuelle de

diverses informations telles que l’évolution du nombre de tests au cours du temps, l’influence de la

configuration matérielle ou logicielle de l’ordinateur sur les performances du logiciel, ou même

encore l’évolution des performances au sein d’un même produit.

Choix de la technologie

J’ai dû peser le pour et le contre entre 4 technologies de génération de graphiques qui avaient

retenus mon attention : Artichow, pChart, Google Chart et Open Flash Chart.

Artichow

Artichow est une bibliothèque PHP pour générer des graphiques. Elle possède l’avantage d’être

simple à utiliser et d’être rapide. Mais elle ne fut pas retenue pour diverses raisons dont un rendu un

peu trop « scientifique » des graphiques et une mauvaise gestion des légendes.

pChart

pChart est une bibliothèque PHP pour générer des graphiques. Elle possède l’avantage de générer de

jolies graphiques, mais demande une lourde configuration un peu trop rigide en ressource.

26

Google Chart

Google Chart est un service offert par le moteur de recherche Google pour générer facilement divers

graphiques facilement personnalisable, ayant un rendu relevant de celui de « Google » (simple et

sobre), permettant de faire des graphiques animés et interactifs. Cette solution ne fut pas retenue

pour des raisons de confidentialité : en effet, elle nécessite d’envoyer les données du graphique à

Google qui retourne l’image finale.

Open Flash Chart

Open Flash Chart est un outil écrit en langage Flash qui permet de générer facilement des graphiques

animés et hautement personnalisable. Ce fut cette solution qui fut finalement retenue.

Réalisation

Par manque de temps, seulement quelques graphiques ont pu être réalisés. Mais les bases d’un

moteur de génération de graphiques ont été réalisées permettant de réaliser une multitude de

graphiques en peu de ligne de codes.

Figure 18 : Graphiques montrant l'évolution du nombre de tests ajoutés, et leurs consommation en temps

27

Conclusion

Ce stage fut une excellente expérience tant sur le plan de la technique que sur le plan de la communication et de la connaissance de l’entreprise. J’ai été traité comme un employé et non comme un stagiaire. De ce fait, j’ai réellement progressé dans plusieurs domaines. C’était un stage difficile, techniquement parlant, que j’ai réalisé pendant trois mois. La difficulté relevait d’un environnement de développement inconnu et d’un manque d’expérience dans certains domaines. Mais tous les problèmes rencontrés m’ont permis d'accroître considérablement mes connaissances et mon savoir-faire. En ce qui concerne l’aspect technique, j’ai acquis de nouvelles connaissances sur les technologies web que ce soit la programmation coté serveur avec le langage PHP, la programmation coté client avec le langage JavaScript ou même les bases de données au travers de SQLite et MySQL. De plus, l’utilisation de Python pour faire divers scripts d’administrations m’a permis non seulement de progresser dans ce langage mais aussi de me rendre compte de l’utilité de connaître un langage de script permettant de réaliser des actions qui ne sont pas forcément compliquées à la main, mais souvent longues et retentissantes. Avec les différentes tâches diverses et variées que j’ai effectué, je suis maintenant capable de comprendre du code qui m’est inconnu et de trouver rapidement un disfonctionnement. A mes yeux, le plus important est de savoir architecturer correctement un projet. En outre, savoir produire un code clair et réutilisable, même si il est parfois plus long à élaborer, permet de gagner un temps précieux. Ce stage qui constitue ma première expérience en entreprise m’a permis de vérifier mes connaissances de l’entreprise. J’ai pu constater à quel point la communication au sein d’une équipe et même entre les équipes est importante. Il est parfois inutile de chercher des heures une solution à un problème quand quelqu’un de plus compétent que vous, sur un domaine, pourrait vous expliquer très rapidement quelle est la source du problème. De plus, le fait de dialoguer et d’échanger des idées sur un problème permet bien souvent de stimuler l’esprit et de trouver soit même une solution. J’ai vécu dans l’entreprise différentes périodes, qui ont été plus ou moins calmes. Une entreprise telle que Techsia est rythmée par les périodes de développement. La charge de travail n’est bien sûr pas la même en début de développement qu’à la fin. Quand la date limite de livraison se rapproche, tout le personnel est très actif et pour les développeurs cela se traduit par beaucoup de bugs à corriger rapidement. Pour conclure ce rapport, je suis très content d’avoir choisi ce stage car j’ai pu apprendre et travailler sur des projets intéressants tout en ayant pu observer le fonctionnement de l’entreprise. Je ne pouvais pas mieux espérer pour connaître mon futur environnement de travail.

28

Annexe

Script de migration de SQLite à MySQL #!/usr/bin/env python

#-*- encoding: utf-8 -*-

import MySQLdb as MySQL

import _mysql_exceptions

import sqlite3

# -----------------

# --- CONSTANTS ---

# -----------------

MYSQL_HOST = '127.0.0.1'

MYSQL_DB = 'testserver'

MYSQL_USER = 'testserver'

MYSQL_PASSWD = 'testserver'

SQLITE_DB = 'd:\\project\\testserver\\website\\db\\testserver.db'

# Exemple :

# TABLES = [

# {

# 'table':<table's name>,

# 'sqlite':<select part>,

# 'mysql':<insert part>

# },

# {

# 'table':<table's name>,

# 'sqlite':<select part>,

# 'mysql':<insert part>

# }

# ]

TABLES = [

{

'table':'pc',

'sqlite':'rowid,hostname,lastconnectiondate,workpc,comment,architecture,active,pctime,action',

'mysql':'id,hostname,lastconnectiondate,workpc,comment,architecture,active,pctime,action'

},

{

'table':'product',

'sqlite':'rowid,name,date,istestable,reference',

'mysql':'id,name,date,istestable,reference'

},

{

'table':'productref',

'sqlite':'rowid,productid',

'mysql':'id,productid'

},

{

'table':'testproject',

'sqlite':'rowid,name',

'mysql':'id,name'

},

{

'table':'test',

'sqlite':'rowid,testcase,testfunction,CASE WHEN productmin=\'\' OR productmin=\'0\'

THEN 1 ELSE productmin END,testprojectid',

'mysql':'id,testcase,testfunction,productmin,testprojectid'

},

{

'table':'testsynchro',

'sqlite':'rowid,testlist',

'mysql':'id,testlist'

},

{

'table':'testinwork',

'sqlite':'rowid,testid,pcid,productid,startdate,CASE WHEN synchro=0 THEN NULL ELSE

synchro END,testparameterid,architecture',

'mysql':'id,testid,pcid,productid,startdate,synchro,testparameterid,architecture'

},

{

'table':'testparameter',

29

'sqlite':'rowid,name',

'mysql':'id,name'

},

{

'table':'testpipe',

'sqlite':'rowid,testid,productid,alwaysplayed,CASE WHEN pcid=0 THEN NULL ELSE pcid

END,testparameterid,architecture',

'mysql':'id,testid,productid,alwaysplayed,pcid,testparameterid,architecture'

},

{

'table':'teststats',

'sqlite':'rowid,pcid,testid,totaltime,numbertestok,avg,bestvalue,worstvalue,bestproduct',

'mysql':'id,pcid,testid,totaltime,numbertestok,avg,bestvalue,worstvalue,bestproduct'

},

{

'table':'testresult',

'sqlite':'rowid,testid,pcid,productid,startdate,stopdate,nbok,nberror,nbfail,detail,duration,t

wrowid,errorcode,testparameterid,architecture,CASE WHEN synchro=0 THEN NULL ELSE synchro END',

'mysql':'id,testid,pcid,productid,startdate,stopdate,nbok,nberror,nbfail,detail,duration,twrow

id,errorcode,testparameterid,architecture,synchro'

}

]

# -----------------

# --- FUNCTIONS ---

# -----------------

def create_select_query(table, structure):

return "SELECT %s FROM %s;" % (structure, table)

def create_insert_query(table, structure, row):

query = ["INSERT INTO %s(%s) VALUES (" % (table, structure)]

for cell in row:

if (cell == None):

query.append("NULL")

elif (isinstance(cell, (str, unicode))):

query.append("'%s'" % cell)

else:

query.append("%s" % cell)

query.append(',')

query.pop()

query.append(");")

return ''.join(query)

# -------------

# --- BEGIN ---

# -------------

print "--------------------------------------"

print "--- SQLite2MySQL Database Migrator ---"

print "--------------------------------------"

print "Copyright 2010, Jonathan Tremesaygues <killruana@gmail.com>"

print

# Connection

print "---CONNECTION---"

print " (1/2) Connect to MySQL...",

mysql_connection = MySQL.connect(host=MYSQL_HOST, user=MYSQL_USER,

passwd=MYSQL_PASSWD, db=MYSQL_DB)

mysql_cursor = mysql_connection.cursor()

print "Done !"

print " (2/2) Connect to SQLite...",

sqlite_connection = sqlite3.connect(SQLITE_DB)

sqlite_cursor = sqlite_connection.cursor()

print "Done !"

print

# Cleaning

print "---CLEANING---"

for i in xrange(len(TABLES)-1, -1, -1):

table = TABLES[i]['table']

print " (%i/%i) Clean table %s... " % (len(TABLES)-i, len(TABLES), table),

mysql_cursor.execute('TRUNCATE TABLE %s;' % table)

30

print "Done !"

print

INTEGRITY_ERRORS = []

# Next,Process

print "---TRANSFERING---"

for i in xrange(0, len(TABLES)):

table = TABLES[i]['table']

sqlite_structure = TABLES[i]['sqlite']

mysql_structure = TABLES[i]['mysql']

print " (%i/%i) Transfer table %s... " % (i+1, len(TABLES), table),

# Create SELECT query

select_query = create_select_query(table, sqlite_structure)

# Execute SELECT query

sqlite_cursor.execute(select_query)

# Processing...

for row in sqlite_cursor:

#Create INSERT query

insert_query = create_insert_query(table, mysql_structure, row)

try:

mysql_cursor.execute(insert_query)

except _mysql_exceptions.IntegrityError: # Integrity Error (foreign key sux)

INTEGRITY_ERRORS.append(insert_query)

print "Transfert done ! ",

mysql_connection.commit()

print "Commit done !"

# Deconnection

mysql_cursor.close()

sqlite_cursor.close()

# Display errors

#for error in INTEGRITY_ERRORS:

# print error

Script de mise à jour des descriptions des tests #!/usr/bin/env python

#-*- coding: utf-8 -*-

import ConfigParser

import MySQLdb

import sys

import imp

import unittest

# Importation de la configuration

config = ConfigParser.ConfigParser()

config.read('testDescriptionUpdater.conf')

MYSQL_HOST = config.get('mysql', 'host')

MYSQL_DB = config.get('mysql', 'database')

MYSQL_USER = config.get('mysql', 'user')

MYSQL_PASSWD = config.get('mysql', 'password')

TESTS_PATH = config.get('tests', 'path')

# Connection à la base de données

mysql_connection = MySQLdb.connect(host=MYSQL_HOST, user=MYSQL_USER,

passwd=MYSQL_PASSWD, db=MYSQL_DB)

mysql_cursor = mysql_connection.cursor()

# Récupère tous les testcases/tesfunctions

testcases = {}

query = "SELECT testcase, testfunction FROM test"

mysql_cursor.execute(query)

for row in mysql_cursor:

testcase = row[0]

testfunction = row[1]

if not testcase in testcases:

31

testcases[testcase] = []

testcases[testcase].append(testfunction)

# On ajoute le path des tests à la variable pythonpath

sys.path.append(TESTS_PATH)

query = ""

for testcase in testcases:

try:

file, pathname, description = imp.find_module(testcase)

mon_module = imp.load_module(testcase, file, pathname, description)

sys.modules[testcase] = mon_module

except ImportError, p:

pass

#print "Unsuccefull import of %s : %s" % (testcase, p)

except NameError, p:

pass

#print "Unsuccefull import of %s : %s" % (testcase, p)

else:

#print "Succefull import of %s" % testcase

if (eval("%s.%s.__doc__" % (testcase, testcase), sys.modules) is not None):

testcase_description = eval("%s.%s.__doc__" % (testcase, testcase), sys.modules)

else:

testcase_description = ""

#print "%s : %s" % (testcase, testcase_description)

for testfunction in testcases[testcase]:

if (eval("%s.%s.%s.__doc__" % (testcase, testcase, testfunction), sys.modules) is

not None):

testfunction_description = eval("%s.%s.%s.__doc__" % (testcase, testcase,

testfunction), sys.modules)

else:

testfunction_description = ""

#print "\t%s : %s" % (testfunction, testfunction_description)

query = "UPDATE test SET testcase_description=\"%s\",

testfunction_description=\"%s\" WHERE testcase='%s' AND testfunction='%s';\n" %

(testcase_description, testfunction_description, testcase, testfunction)

mysql_cursor.execute(query)

mysql_connection.commit()

mysql_cursor.close()