Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de...

43
Florian DELMAS Syndicat Inter-hospitalier du Limousin I.U.T. du Limousin Département Informatique Maître de stage : M. Thierry BERTHIER Complément au logiciel de supervision '' Nagios '' Rapport de stage réalisé du 26 Mars au 22 Mai 2007 Deuxième année de DUT Informatique Année universitaire 2006-2007 1

Transcript of Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de...

Page 1: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Florian DELMAS Syndicat Inter-hospitalier du Limousin

I.U.T. du Limousin Département Informatique Maître de stage :M. Thierry BERTHIER

Complément au logiciel de supervision '' Nagios ''

Rapport de stage réalisé du 26 Mars au 22 Mai 2007

Deuxième année de DUT Informatique Année universitaire 2006-2007

1

Page 2: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Je remercie M. Alain MENIEUX pour son accueil au sein de l'établissement ainsi que Xavier LEVRAT pour son aide sur Nagios.

Mes remerciements vont aussi à Marc PODAVINI qui m'a éclairé sur les fonctionnalités de Customer First.

2

Page 3: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Résumé

Le réseau du Syndicat Inter-hospitalier du Limousin (ou SIL) est géré par l'outil de supervision Nagios. Durant ce stage, j'ai élaboré un complément à cet outil. Il permet de calculer les statistiques de disponibilité du réseau du SIL, en s'appuyant sur les données de Nagios.

Les deux premières semaines, je me suis attaché à configurer mon serveur Web de tests et à suivre quelques tutoriels du Zend Framework – le framework PHP que j'ai utilisé pour l'implémentation de mon application.

Après cette phase de mise en place de mon espace de travail, j'ai analysé l'existant afin de bâtir une vision solide de mon application.

Puis, je l'ai implémenté en PHP, avec le Zend Framework qui propose une programmation orientée objet, avec un modèle MVC.

Enfin, j'ai essayé de résoudre des problèmes d'intégrations de mon produit dans l'établissement.

Arrivé à bon terme, le stage a été très enrichissant pour moi, à la fois dans la programmation en PHP et dans ma vision du monde du travail.

3

Page 4: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

4

Page 5: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Sommaire

Introduction....................................................................................................................... 6

I. Présentation des éléments clés du stage......................................................... 7

A. Le SIL, l'établissement d'accueil ................................................................ 7

B. Nagios et son complément........................................................................... 9 i. Nagios, outil de supervision réseau..................................................... 9 ii. Le complément de Nagios, sujet du stage............................................ 9

C. Les choix conceptuels du projet..................................................................10 i. Les choix pratiques................................................................................. 10 ii. Le Zend Framework, un framework d'avenir....................................... 12 iii. Le choix des outils d'analyse................................................................. 14

D. Le déroulement du projet..............................................................................15

II. La construction de l'application.........................................................................16

A. L'élaboration de la base de données........................................................... 16 i. Liaison entre deux bases de données................................................... 16 ii. Approfondissement sur le contenu de la nouvelle base..................... 16

B. L'analyse avec UML, prise en compte du modèle MVC............................. 20 i. Découpage chronologique des fonctionnalités................................... 20 ii. La prise en compte du modèle MVC...................................................... 22

III. L'implémentation au travers du Zend Framework........................................... 24

A. L'affichage, le premier aperçu de l'application........................................... 24

B. L'implémentation avec le Zend Framework................................................ 29 i. Le fichier boot strap................................................................................ 29 ii. Les contrôleurs....................................................................................... 30

a) Architecture principale de l'action ''hoteAction'' ........................... 31 b) Aperçu d'une des fonctions de calculs des statistiques............... 34

iii. Les vues................................................................................................... 39

C. Les problèmes d'intégration.........................................................................41

Conclusion........................................................................................................................ 42

5

Page 6: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Introduction

L'efficacité d'un service peut se visualiser au travers de statistiques élaborées sur des indices pertinents. C'est dans ce souci de connaissance de la qualité que le besoin d'un complément à Nagios spécialisé dans ce domaine, est apparu au sein du Syndicat Interhospitalier du limousin (ou SIL), mon établissement d'acceuil. En effet, Nagios – logiciel de supervision de réseau utilisé par le SIL – n'a pas de fonctionnalité permettant de visualiser les statistiques du réseau sur une periode. Or le réseau géré par le SIL compte un certain nombre de machines appartenant à ses adhérants. Le complément a pour but de combler ce manque, afin d'avoir un regard sur la qualité offerte par le SIL à ses adhérants dans l'administration de son réseau.

Dans un premier temps, nous introduirons les éléments fondamentaux du stage. Après une présentation du SIL et de Nagios, j'aborderai le point central du stage : le complément de Nagios. J'aborderai aussi les choix que j'ai été amené à faire et le travail réalisé.

Puis nous détaillerons les deux études de l'analyse du projet. La première définit les éléments présents avant mon arrivée au SIL et leur impact sur le développement de mon application. La deuxième étude est un découpage de ses fonctionnalités.

Enfin, nous verrons comment l'implémentation a été réalisée avec le Zend Framework. Je détaillerai les fonctions les plus importantes pour avoir un aperçu concret, et j'expliquerai les différences qu'il y a avec l'analyse et pourquoi elles sont nécessaires.

6

Page 7: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

I. Présentation des éléments clés du stage

A. Le SIL, l'établissement d'accueil

Le SIL est une administration publique créée par arrêté préfectoral en date du 16 Novembre 1987. Il est administré par un conseil d'administration et dirigé par sa secrétaire générale, Carole BLANCHARD. Grâce au SIL, les établissements sanitaires et sociaux, tels que des hôpitaux, des maisons de retraites, ont accès à un soutien dans le secteur informatique en y adhérant.

Historiquement, le SIL s'occupait de la gestion financière de ces établissements. Par exemple, la gestion des fiches de paye était totalement prise en charge.Maintenant, cette gestion est toujours prise en charge mais n'est plus majoritaire dans son activité. En effet, le SIL a étendu ses services de manière à pouvoir proposer de l'infogérance et un support informatique aux établissements du domaine médical. Il se propose même comme pouvant être le fournisseur d'accès à internet à ses adhérents. Ceci se matérialise par la présence importante de matériels informatiques tels que des serveurs ( une trentaine au total ) dans les locaux du SIL. De même, un service de maintenance et d'assistance est à la disposition des adhérents.

Le SIL a déjà plus d'une centaine d' adhérents à son actif et tous ne font pas forcément partie de la région. Par exemple, il intervient dans des établissements de Provence, des Alpes, de Côte d'azur et aussi de région parisienne. Selon la taille de l'établissement, les interventions du SIL diffèrent. Elles peuvent être divisées en deux catégories :

- Pour les grosses structures, le SIL ne gère qu'une partie précise de ces établissements ( généralement celle qui concerne la distribution de logiciels, avec son support )

- Pour les petites structures, le SIL leur propose de l'infogérance ainsi qu'un soutien dans le déploiement de matériels informatiques.

Le SIL est composé d'une soixantaine de personnes. Une dizaine d'entre-elles participent à l'association Reimp'Hos. Cette association a pour vocation de créer un réseau de communication entre les équipes hospitalières sur les données des patients du domaine public ou privé et travaillent main dans la main avec le SIL. Elle souhaite aussi créer "Santé limousin", un projet qui a pour objectif de rassembler l'ensemble des données médicales pour chaque patient.

7

Page 8: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Voici l'organigramme actuel du SIL :

Le bâtiment du SIL est basé à Isle - situé dans la périphérie de Limoges - au sein d'une zone résidentielle. Il est composé deux étages et un sous-sol :

- le rez-de-chaussée contient la partie production du SIL ( bulletin de paye, CD-rom ... ),

- le premier étage est réservé à la partie technique et informatique,

- le deuxième étage comporte la salle de réunion ainsi que des bureaux,

- au sous-sol,sont entreposés les serveurs et les imprimantes. Il contient aussi le garage des voitures du SIL pour intervenir rapidement chez les adhérants.

Le SIL prévoit d'agrandir ses locaux par la construction d'un autre bâtiment situé à proximité.

Le premier étage - réservé à la partie technique et informatiques - est composée de plusieurs pièces où certains pôles d'activités sont regroupés :

- la première pièce regroupe l'équipe du support technique des logiciels Windows et l'assemblage d'ordinateurs, - la deuxième regroupe les techniciens réseaux et du support technique Linux, - la troisième concerne les applicatifs de Reimp'Hos - la quatrième concerne le réseau et les télécommunications.

C'est dans cette dernière pièce que se situe mon bureau, au côté de monsieur MENIEUX - mon responsable de stage - et de monsieur BOISSEUIL.

8

Page 9: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

B. Nagios et son complément

Le complément de Nagios que j'ai développé, permet de réaliser des statistiques sur des éléments du réseau géré par le SIL. Avant de voir l'intégralité des fonctionnalités de ce complément, je vais expliquer ce qu'est le logiciel principal, c'est à dire Nagios.

i. Nagios, outil de supervision réseau

Nagios est un logiciel libre de supervision de réseaux informatique complet. Il permet de connaître l'état de l'ensemble des machines d'un réseau ainsi que leurs caractéristiques à partir d'un simple navigateur Web ; comme par exemple, la capacité mémoire restante sur leurs disques durs, la température et le taux d'activité des processeurs. Ces machines sont appelées des hôtes car elles "hébergent" des services. Un grand nombre de mini-programmes ( ou plug-ins ) peuvent être installés dans Nagios afin d'enrichir ses fonctionnalités, comme "NCDOUtils" en lui donnant ainsi la possibilité d'archiver les données. de Nagios dans une base de données.

Si un problème survient dans un réseau complexe qui comporte des machines dépendantes d'autres machines, Nagios peut déterminer quelle machine pose le plus de problèmes.En terme de compatibilité, Nagios supporte la plupart des systèmes d'exploitation comme Linux ou Windows.

ii. Le complément de Nagios, sujet du stage

L'objectif principal de mon application est de pouvoir visualiser les statistiques du réseau et éditer des comptes rendus sur la qualité du service du SIL pour informer les adhérents et pour le SIL lui-même. On s'attache donc à savoir si un hôte a été fréquemment hors service ou non, et dans quelle période.

L'ensemble des fonctionnalités ont été définies avec Alain MENIEUX ainsi qu'avec Xavier LEVRAT – utilisateur principal de Nagios au SIL.

L'application doit permettre à l'utilisateur de :

- sélectionner un ou plusieurs hôtes, dont il souhaite avoir les statistiques

- sélectionner une plage horaire personnalisée ou contractuelle

- saisir l'heure de début et de fin de l'horaire dans le cadre de la plage horaire personnalisée

- formater le tableau des statistiques au format XML ou PDF.

Ce dernier point donne la possibilité à l'utilisateur de réaliser un compte-rendu sur les statistiques annoncées. Ainsi elles pourront être utilisées de manière concrète en dehors de l'application.

Le point fondamental de l'application est de déterminer si un hôte est hors service ou non, pour calculer les statistiques. Pour cela, j'ai dû me servir de la base de données générée par NCDOUtils pour y parvenir, mais une autre base de données a dû être prise en compte dans mon application.

9

Page 10: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

En effet, lors de la mise en place d'un matériel informatique, le SIL est amené à :

- référencer les données de l'adhérent qui en fait la demande, - référencer les machines proposées, - réaliser le suivi technique de ce matériel.

Le référencement du matériel informatique et son suivi technique sont possibles grâce à Nagios, alors que le référencement des données des adhérents est réalisé avec le logiciel Customer First. Ce logiciel est un logiciel d'aide à la gestion des appels Hotline. Par exemple, on peut y saisir les coordonnées des clients, leurs matériels etc.

La problématique soulevée par l'utilisation de ces deux logiciels est que l'on ne peut pas connaître l'ensemble des données d'un matériel à partir de la même interface puisque l'outil de supervision Nagios n'enregistre que les données techniques du matériel, alors que Customer First ne permet ni de connaître l'état des machines présentes sur le réseau, ni l'architecture du réseau.Pour les activités du SIL, ces deux logiciels sont donc dépendants l'un de l'autre.

Une information, que nous ne pouvons pas connaître ni dans Nagios ni dans Customer First, est la position géographique des matériels informatiques. Dans Nagios, le problème reste le même : les données sur les machines sont purement techniques. Dans Customer First, seules les données des entités juridiques y figurent. Ainsi, pour un établissement important comportant plusieurs sites géographiques, seule son adresse principale sera enregistrée. Or lorsqu'un problème de réseau survient dans Nagios, il est important de pouvoir connaître où se situe le matériel en cause, afin de traiter rapidement le problème.Concrètement, ces données sont enregistrées dans un tableau Excel pour faire la correspondance entre le propriétaire, la machine et sa localisation.

Le complément logiciel à Nagios, que je devais développer, avait pour but de prendre en compte ces informations puisqu'elles permettent de fournir des statistiques plus précises sur les matériels gérés par le SIL, les rendant ainsi plus utiles, aussi bien pour les adhérents que pour le SIL.

C. Les choix conceptuels du projet i. Les choix pratiques

Mon application a été réalisée sous la forme d'un site Web, permettant ainsi d'être consultable avec un simple navigateur Web. Le but de ce choix est de rendre mon application transportable, simple à maintenir et à utiliser quelque soit le poste où l'utilisateur se situe.

Elle aurait pu être réalisée en tant que qu'application indépendante. Mais dans ce cas, il aurait été nécessaire d'installer de nouveaux composants sur les ordinateurs pour pouvoir y accéder. Une telle solution n'était pas envisageable, car cela aurait alourdi le travail des administrateurs et les nouveaux composants risqueraient de générer des conflits avec les programmes déjà installés.

C'est pourquoi, la solution du site Web est apparue comme la plus appropriée et la moins contraignante.

Le langage de développement que j'ai utilisé, était le PHP. Ce langage est devenu un standard dans la création de site Web lié à une base de données. Il permet de générer du code HTML pour créer les pages Web en fonction des résultats retournés par le langage de la base de données ( le langage SQL ).

10

Page 11: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Concrètement, le PHP est inséré directement dans une page HTML. Le fichier prend alors l'extension ''.php'' ou ''.phtml''. Lors du lancement de la page, le serveur Web lance son fichier contenant du code PHP et l'exécute. Une fois cette exécution terminée, le serveur Web a la page Web terminée - générée par le PHP. Il peut alors l'envoyer à l'utilisateur.

Ceci présente un avantage sur la sécurité : comme c'est le serveur Web qui exécute le code PHP en interne et qu'il n'est visible que part lui, l'utilisateur ne peut ni déterminer la forme de la base de données, ni envoyer du code PHP dans un but malveillant.Dans notre cas, cet aspect sécuritaire n'est pas important dans le choix du langage puisque le complément a été prévu pour être utilisé par les responsables des bases de données et du réseau, mais il est tout de même notable puisque c'est l'une des forces de ce langage.

D'autres langages auraient pu être utilisés pour créer un site Web. J'aurais pu par exemple créer une applet Java au sein de la page HTML. Java sait très bien faire la liaison avec une base de données et permet de rendre une page Web interactive sans avoir besoin de la rafraichir intégralement, contrairement au PHP. Cependant, développer en Java supposerait de devoir installer ses composants sur tous les postes où la consultation du complément est nécessaire. Encore une fois, ceci est à éviter pour des problèmes de place mémoire et de compatibilités. De plus, mon produit est destiné à un établissement et sera peut être amené à évoluer. Dans ce sens, il est préférable d'utiliser un langage relativement connu pour permettre à l'établissement de modifier le code source facilement en fonction de ses besoins.

Mon espace de développement est Eclipse. Ce logiciel libre développé par Eclipse Foundation, est un espace de développement complet, avec une arborescence des projets, le support de plusieurs langages de programmation, ainsi que la possibilité d'ajouter des fonctionnalités via des plug-ins.

Pour travailler dans de bonnes conditions sur un site Web, il faut pouvoir tester ses pages de façon rapide et optimale. De cette façon, nous pouvons voir tout de suite le résultat de la programmation et corriger le code si besoin est. La mise en oeuvre d'un site Web passe par la configuration d'un serveur Web. Même si plusieurs logiciels open source permettent d'en configurer un rapidement sous Windows, nous avons configuré un serveur sous Linux. Le but de cette solution est de permettre un déploiement rapide du site Web. Le serveur Web de développement doit donc être le plus proche possible du serveur final sur lequel sera mon site Web. Ainsi, tout problème de compatibilité et de configuration sera résolu.

Eclipse tourne sous Windows et mon serveur Web doit tourner sous Linux. Un problème se pose : comment installer et interfacer les deux parties ? Le serveur est uniquement un serveur de tests, il n'est donc pas justifié de monopoliser un ordinateur uniquement pour cette tâche. Nous avons donc choisi d'installer un logiciel de virtualisation (VMWare) pour simuler un deuxième ordinateur sur le même ordinateur. D'un point de vue pratique, le logiciel affiche une fenêtre qui représente l'écran du deuxième ordinateur. Sur celui-ci, j'y ai installé une distribution de Linux (Fedora) ainsi que tous les modules requis pour en faire mon serveur Web.

11

Page 12: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

ii. Le Zend Framework, un framework d'avenir

Les frameworks PHP sont des bibliothèques logicielles pour les applications développées en PHP. Elles sont généralement développées autour d'un concept visant à structurer l'application et à mettre en oeuvre les derniers procédés en matière de programmation. Le but principal des frameworks est d'accélérer la programmation en fournissant des fonctions élémentaires, pour éviter aux développeurs de toujours devoir les reprogrammer à chaque nouveau projet. Il en existe prés d'une vingtaine. Les frameworks PHP les plus connus sont PEAR, Symfony, CakePHP et Horde.

Nous avons choisi le Zend Framework pour mon application. Ce framework m'a été proposé par Xavier LEVRAT. Il est développé par Zend - entreprise pionnière dans le développement du langage PHP. Il permet d'accélérer la programmation en proposant des fonctions pour le formatage de requêtes SQL, le formatage des dates, la gestion d'authentification, la fonction de recherche et bien d'autres fonctions encore. Il permet aussi de programmer un site Web en PHP orienté objet, avec un modèle MVC ( Modèle Vue Contrôleur ).

Ce modèle MVC a pour objectif de séparer différentes partie du code afin de faciliter la lecture du code et la maintenance.

Les trois partie sont :

- Les modèles qui englobent les enregistrements d'une base de données ainsi que l'interface entre le programme et celle-ci,

- Les vues qui représentent la partie affichage du programme,

- Les contrôleurs qui ont pour rôles d'interface la partie vue et la partie modèle en contrôlant les informations provenant de ces deux parties.

Le Zend framework intègre parfaitement cette notion puisque l'arborescence conseillée par Zend consacre un dossier pour chaque partie.

La voici plus en détail :

Le dossier ''application'' contient un dossier pour chaque partie du modèle MVC.

Le dossier ''library'' contient toutes les fonctions utiles au projet, dont les fonctions du Zend Framework.

Le dossier ''public'' est le dossier qui recense tout ce dont le navigateur Web a besoin pour afficher le site.

Rappelons que l'application est un site internet, il est donc nécessaire de mettre en place certaines contraintes pour mettre en oeuvre une telle arborescence. En effet, si nous mettons un site internet en ligne avec une telle arborescence, l'utilisateur aurait accès à des dossiers qui ne lui sont pas réservés en mettant le chemin du dossier dans l'adresse internet. Par exemple, l'adresse ''http://monsite.fr/application/models'' donnerait accès au dossier "models" de l'arborescence ci-dessus.

12

Page 13: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Pour limiter les accès de l'utilisateur, il faut créer des fichiers ".httpaccess" dans les dossiers que nous souhaitons bloquer. Ces fichiers contiennent les règles d'accès aux dossiers.Ils sont lus par le serveur Web.

Maintenant, attachons nous au fonctionnement même de d'une application développée avec le Zend Framework. Il comporte deux notions importantes :

Le boot strapping :

En utilisant un framework, nous appliquons des fonctions et des concepts propres à celui-ci. Afin que le serveur Web puisse les interpréter, nous devons charger la librairie du framework à chaque page. De manière à éviter de faire des doublons dans notre code, cette partie du programme est généralement mise dans un fichier indépendant. A chaque chargement de page, ce fichier est systématiquement appelé afin de charger le contenu utile du framework. C'est ce que l'on appelle la méthode de boot strapping. Ceci reste transparent pour l'utilisateur, car le programme charge ensuite la page demandée tout en affichant l'adresse de cette page.

Le format de l'adresse :

Dans ce framework, l'adresse internet ( ou URL ) a une signification du point de vue du modèle MVC. Voici un exemple, pour un site Web nommé ''www.monsite.fr'' :

http://www.monsite.fr/controleur/action/parametre/valeur

"controleur" indique que le serveur Web est passé par le contrôleur du même nom pour afficher la page "action" avec en paramètre la valeur "valeur" au paramètre "parametre".Ainsi si nous voulons gérer des news à l'intérieur de notre site Web, le contrôleur sera "news" et les différentes actions seront "ajout", "modif" et "suppr".Les différentes adresses de notre site seront alors :

http://www.monsite.fr/news/ajouthttp://www.monsite.fr/news/modifhttp://www.monsite.fr/news/suppr

Au niveau de l'implémentation, il suffira de créer les classes des contrôleurs dont on a besoin en rajoutant "Controller" à leur nom, dans le dossier qui leur sont réservées. De la même manière, les actions sont des fonctions implémentées dans leurs contrôleurs en rajoutant "Action". Dans notre exemple de gestion de news, cela se traduira par une classe "newsController" dans le dossier réservé aux contrôleurs. Elle contiendra les actions "ajoutAction", "modifAction" et "supprAction". Cette convention de nommage permettra au serveur Web de lancer automatiquement les vues associées à ces actions, qui se trouveront dans le dossier "views".

Nous ne sommes cependant pas obligés de renseigner systématiquement l'ensemble de ces champs pour afficher une page. C'est là qu'intervient l'index.Les fichier "index" servent de pages Web par défaut et ils sont transparents dans l'adresse URL. Ainsi un site Web qui affiche en page d'accueil une adresse URL ressemblant à ''http://www.monsite.fr" lance un fichier d'index. L'adresse URL réelle serait alors "http://www.monsite.fr/index.php ".Nous retrouvons cette convention dans le Zend Framework pour afficher une adresse URL cohérente avec la page demandée, où l'index a cette double notion. L'implémentation d'un index en tant qu'action sera simplement une action nommée "indexAction".

13

Page 14: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

De même, pour aller plus loin, un contrôleur index peut être créé en ajoutant une classe "indexController".De cette manière, une adresse telle que ''http://www.monsite.fr/index/index'' sera équivalente à une adresse telle que ''http://www.monsite.fr'' et tous les contrôles de cette page seront implémentés dans l'action "indexAction" du contrôleur "indexController".

Enfin, la valeur d'un paramètre dans l'adresse peut être intéressante à utiliser si nous n'avons que peu d'objets à gérer. Une application simple à cette utilisation est dans le cadre de la suppression d'un objet : nous mettons l'identifiant de l'objet en paramètre et la valeur de l'identifiant de l'objet à supprimer. Pour supprimer une news qui aurait l'identifiant "id" égale à 6, l'adresse de suppression de cette news serait http://www.monsite.fr/news/suppr/id/6.Si l'utilisateur clique sur un lien comportant cette adresse, la page de suppression de la news correspondante s'affichera.

L'application de ces différentes règles permet d'avoir un site organisé et robuste dans sa conception, car elles obligent à bien délimiter les différentes possibilités du site pour mieux les organiser, sans toute fois empêcher le site d'évoluer.

De plus, le concept du modèle MVC permet une meilleure évolutivité du programme et une meilleure maintenance car l'ensemble du programme est réparti dans différents groupes.

Le Zend Framework est pour l'instant jeune puisqu'il n'est encore qu'en phase de développement, mais comme son entreprise créatrice reste une référence dans la programmation en PHP, il sera amélioré et étoffé en cours de plusieurs années. Et le site Web que j'ai réalisé n'était pas un projet de grande envergure, c'était donc une bonne opportunité pour moi pour tester ses premières possibilités.

iii. Le choix des outils d'analyse

Dans la conception d'un applicatif informatique, la phase d'analyse est une phase très importante car elle permet de définir l'ensemble de ses fonctionnalités et d'avoir un premier aperçu du travail à réaliser. Il convient donc de choisir les outils d'analyses les mieux adaptés au projet afin d'en avoir une vue claire et précise.

J'ai choisi de faire une première étude en UML, car ce langage intègre parfaitement la notion du modèle MVC. Cependant je n'ai pas fait une étude dans son intégralité, car il aurait inutile d'aller jusqu'au bout. En effet, UML propose d'aller jusqu'à la définition des classes des objets de l'application, ainsi que dans le découpage des interactions entre les différentes couches du modèle MVC. Une grande majorité des classes existaient déjà, puisque je me basais sur des bases de données existantes et comme elles sont nombreuses, il aurait été fastidieux et laborieux de détailler les interactions pour chacune d'elles. Et le résultat aurait été sans doute inutilisable pour le développement, car il aurait été beaucoup trop dense en informations pour une utilisation efficace. J'ai donc préféré rassembler les différentes classes par base de données pour avoir une première ébauche lisible des interactions dans mon programme.

Ensuite, je me suis attaché au développement de ma base de données à l'aide de la méthode Merise. Encore une fois, j'aurais pu le réaliser avec le langage UML, seulement les liaisons entre les tables de ma base de données et les clés étrangères auraient été moins évidentes à retrouver lors de l'application au langage SQL.

J'ai choisi la méthode Merise, pour avoir une vue d'ensemble directe et rapide de la base de données et des liaisons entre les tables qui la composent, notamment avec le modèle conceptuel de données et le modèle physique des données.

14

Page 15: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

D. Le déroulement du projet

Le travail, que j'ai réalisé durant ces dix semaines, peut être découpé en quatre parties :

Numéro des semaines

Partie réalisée Commentaire

1 ~ 2 Configuration du poste de travail et tutoriels du Zend Framework

La configuration prend en compte l'installation du logiciel de virtualisation, du logiciel de développement, du serveur web et sa configuration.

3 ~ 4 L'analyse Elle englobe l'étude avec le langage UML et la méthode Merise

5 ~ 8 Le développement Cette partie est l'implémentation de l'analyse au moyen du Zend Framework

9 ~ 10 L'intégration du projet dans l'établissement

Dans cette partie, j'ai essayé de résoudre certains problèmes d'intégration que posait mon application.

Les parties les plus délicates ont été la configuration du poste de travail et le développement.

La configuration du poste de travail a été délicate sur plusieurs points, en particulier pour la configuration du serveur Web. En effet, ce serveur était sous Linux en mode commande et comme je ne maîtrise pas pleinement ce système d'exploitation, j'ai eu des difficultés pour installer les modules. La commande ''yum'' m'a bien été utile car elle permet de récupérer un module voulu avec tous les autres modules nécessaires pour le faire fonctionner. Seulement, avec cette commande, tous les modules ne sont pas disponibles. Par exemple, le module ''php-mssql'', qui permet d'utiliser Microsoft SQL Server sur un serveur Web Linux, est introuvable via cette commande.

J'ai dû rechercher sur internet où il était disponible et comment l'installer. Après plusieurs installations différentes, j'ai finalement trouvé un site Web qui le recensait. Ce site Web expliquait comment le rattacher à la commande ''yum'' pour télécharger ses modules. Une fois la manipulation faite, j'ai pu installer le module.

Enfin la partie du développement a été longue car j'ai du adapter mon analyse au Zend Framework qui était nouveau pour moi. J'ai dû me documenter et réaliser plusieurs tests avant d'avoir des résultats convainquants, malgré les tutoriels réalisés les premières semaines.

Pour les deux autres parties du projet, je n'ai pas eu de grosses difficultés.L'analyse était moins dure que certaines études de cas que j'ai réalisé. Et j'ai rapidement su résoudre une partie des problèmes pour l'intégration de mon produit.

15

Page 16: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

II. L'analyse

A. L'élaboration de la base de données

i. Liaison entre deux bases de données

L'un des premiers points auquel je me suis attaché de définir, est comment lier la base de données de Customer first à la base de données de Nagios.Ces deux bases de données proviennent de deux logiciels totalement différents et leurs langages ne sont pas les mêmes non plus. La base de données de Customer First est en Micrsoft SQL Server alors que la base de données de Nagios est en MySQL. Il est donc impossible de créer une seule base de données à partir de ces deux-là.

Customer First recense une grande partie des machines gérées par le SIL et ce logiciel propose des champs de saisie personnalisables à leurs utilisateurs.C'est par cette constatation que la première solution est née. Pour lier les deux bases données, il faudrait rajouter ( dans Customer First ) l'identifiant Nagios de chaque machine dans ces champs personnalisables.Ainsi, nous pourrions savoir quelle machine de Customer First correspond à quelle machine dans Nagios puisque l'identifiant Nagios serait à la fois dans Customer First et dans Nagios. Une fois cette liaison établie, nous pourrions récupérer l'organisme propriétaire de la machine à l'intérieur même de la base de données de Customer First.Mais cette solution n'a pas été retenue par manque d'évolutivité car elle nécessite de faire appel à des champs qui risquent de disparaître ou d'être modifier au cours des versions. La solution serait valable pour la version actuelle du logiciel, mais pas nécessairement pour les suivantes.

En prenant différemment la solution, nous avons également pensé à ajouter un identifiant, non pas dans Customer First, mais dans Nagios. La valeur de l'identifiant serait alors celle de Customer First et l'ajout se ferait de façon normalisée dans le nom de la machine côté Nagios. Le problème serait légèrement amélioré, puisque les utilisateurs de Nagios pourraient savoir à quelle organisme correspond telle ou telle machine, à partir de leur base de données.Cette solution n'a pas non plus été retenue puisque elle contraint de rajouter un identifiant dans un champs déjà occupé. Dans certains cas, des problèmes de tailles et de compatibilités pourraient survenir.

De plus, avec ces deux solutions, nous n'avons pas le site géographique de la machine car cette information n'est enregistrée ni dans Customer First ni dans Nagios.

Nous avons choisi de réaliser une base de données qui aurait un rôle d'interface entre la base de données de Nagios et la base de données de Customer First. De cette façon, nous ne touchons à aucune information contenue dans Nagios ou dans Customer First et nous pouvons rajouter les informations dont nous avons besoin dans cette nouvelle base de données.

Pour faire la liaison entre les deux bases de données, la table contenant les informations des machines aura un champs réservé à l'identifiant des hôtes de Nagios et un autre champs réservé à l'identifiant des organismes gérés dans Customer First. D'autres informations pourront être stockées dans cette même table, comme le site géographique, ou des tables à part.

ii. Approfondissement sur le contenu de la nouvelle base

Le problème de connexion entre les bases de données étant résolu, il faut s'attacher à définir le reste de la nouvelle base de données.

Le complément doit donner la possibilité à l'utilisateur de choisir entre une plage horaire personnalisable et une plage horaire contractuelle pour ses calculs de disponibilités.

16

Page 17: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Pour savoir s'il est nécessaire de rajouter ces informations dans notre base, il faut avant tout se documenter sur Nagios pour savoir s'il ne traite pas déjà cette option. Dans Nagios, nous pouvons définir des plages horaires pour les tests d'état des hôtes. On peut par exemple définir que l'état de tel hôte doit être testé entre 8 heures et 17 heures uniquement, pour des raisons qui sont propres au matériel et au responsable du réseau. Le développeur de Nagios conseille tout de même d'avoir une plage de tests la plus large possible pour permettre au responsable réseau de voir l'ensemble des problèmes qu'ont connus les éléments de son réseau.

Un problème peut être récurant et survenir en dehors de la plage horaire contractuelle. Si le responsable du réseau ne prévoit pas une plage horaire suffisamment large, il risque ne pas voir cette anomalie. Or si elle existe, c'est bien parce que l'élément concerné ou n'importe quelle configuration le concernant est mal paramétré. Ainsi, même si cette anomalie intervient en dehors de la plage horaire, elle peut révéler des problèmes de configuration ou des problèmes sur tout élément du réseau. Il est donc recommandé de s'en préoccuper.C'est sur cette idée que le réseau du SIL est géré par Nagios : les tests de Nagios ont lieu 24 heures sur 24, 7 jours sur 7.

Pour des soucis de performance, nous ne pouvons pas nous baser sur les plages horaires de Nagios. Et même en écartant cette raison, cette configuration actuelle de Nagios nous satisfait grandement puisque grâce à celle-ci nous pouvons donner des statistiques réelles, quelque soit la plage horaire demandée. En effet, si Nagios avait respecté les plages horaires pour déterminer quand tester les hôtes, le résultat pour le calcul de plage personnalisée aurait été erroné car il se baserait que sur des tests de la plage contractuelle.

Nous venons de le voir, les plages horaires contractuelles ne sont pas prise en compte dans la configuration actuelle de Nagios. Nous allons compléter notre base de données pour qu'elle prenne en compte ces informations.

Les plages horaires contractuelles appliquées aux équipements du réseau dépendent du groupe des équipements. Comme nous sommes sur un réseau, c'est le débit qui est le plus important à garantir. C'est pourquoi les équipements sont classés par groupe de connexion réseau, et à chacun groupe est attribué une plage horaire contractuelle. Par exemple, un équipement appartenant au groupe " ADSL light " - correspondant aux connexions ADSL des particuliers - aura une plage horaire restreinte. Alors que un équipement du groupe " DLS " - correspondant aux connexions professionnelles - aura une plage horaire beaucoup plus étendue.

Dans cette exemple, nous voyons bien les liaisons existantes entre ces trois éléments. Nous devons compléter notre base de données en tenant compte. De cette façon, nous aurons une table pour les équipements du réseau, liée à la table des groupes de connexion, elle-même liée à la table des plages horaires.

La table des éléments du réseau et la table des groupes ne sont pas compliquées à mettre en place, par contre la plage horaire demande à être plus élaborée.Une plage horaire est définie par une heure de début de période, une heure de fin de période, et de plusieurs dates de jours chômés. Si nous stockons ces données dans une même table, ceci reviendrait à réserver un champs pour les heures de début et de fin de période puis plusieurs champs pour les jours chômés. Tôt ou tard, nous aurons un problème de place avec les jours chômés puisque nous n'allons mettre 365 champs libres. Ceci prendrait une place très importante et nous aurions une redondance des données puisqu'avec cette solution, nous serions obligés de saisir toutes les dates des jours chômés pour chaque plage horaire. Pour éviter ce double problème, nous devons séparer les horaires des dates de jours chômés. Ainsi nous pourrions saisir en une seule fois toutes les dates de jours chômés et nous pourrons faire la liaison entre les dates et les plages horaires grâce à une table intermédiaire.

17

Page 18: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Nous arrivons au modèle de conception de données suivant :

Les liaisons entre les bases de données sont abstraites car elles ne sont pas visibles dans les contraintes de la nouvelle base de données elle-même. Elles seront implémentées au niveau logiciel.

Cependant des contraintes ont été mise en place pour éviter que plusieurs équipements aient le même identifiant des autres bases de données. Si l'utilisateur persiste en essayant d'ajouter un de ces cas particuliers, la requête sera rejetée par une erreur SQL.

Enfin, les base de données de Customer First et de Nagios comportent un très grand nombre de tables. Les représenter ici nuiraient à la compréhension du modèle, c'est pourquoi j'ai préféré ne représenter que les tables qui nous servent de ''point d'entrée'' à ces bases de données. Les liaisons en pointillé à droite marque le fait que d'autres tables existent.

18

Page 19: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Une fois ce modèle élaborée, j'en ai déduit le modèle physique des données. Il permet de visualiser les différentes tables qui composent la base de données avec leurs liaisons.

Par rapport au précédent modèle, nous pouvons remarquer que l'association ''Jour_Chaume'' est devenue une table dans la base de données. C'est cette table qui permet de lier les dates des jours chômés aux plages horaires. Elle contient les couples des identifiants de ces deux autres tables pour faire la correspondance. Nous remarquons aussi que de nouveaux champs ont été ajoutés dans d'autres tables. Ils contiennent les identifiants d'autres tables et permettent de faire leurs liaisons logiques. Par exemple, un équipement appartient à un type d'équipements ( ADLS light , DSL, etc ). Ainsi nous devrons faire un test d'égalité entre les champs '' Type_Equip_ID '' de la table des équipements et des types, pour retrouver le type d'un équipement. Grâce à ce procédé, nous pouvons avoir la totalité des informations d'un équipement ou de tout autre élément de la base de données.Ma base de données étant terminée, j'ai continué mon analyse avec UML.

19

Page 20: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

B. l'analyse avec UML, prise en compte du modèle MVC

i. Découpage chronologique des fonctionnalités

Tout d'abord, j'ai réalisé les ''plans types'' des fonctionnalités de mon application. Ils détaillent textuellement et séquentiellement les opérations utilisateur/machine qui font avancer le déroulement de l'application. Ils ne font pas partie à proprement parler du langage UML mais ils sont une aide pour l'analyse.

En effet , comme ils détaillent chaque action de l'utilisateur ou de la machine, ils m'ont permis de réaliser le diagramme d'activités. Celui aide mieux à la compréhension du déroulement de mon application. Ce diagramme présente séquentiellement les actions réalisables d'une fonctionnalité ainsi que l'ensemble des directions qu'elles entrainent.

A titre d'exemple, nous allons étudier la fonctionnalité des statistiques par hôte.

Voici son diagramme d'activités :

20

Page 21: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

21

Page 22: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Au stade de l'analyse, nous n'avions pas la totalité de l'implémentation en tête ce qui a occasionné quelques erreurs dans l'analyse. Ce diagramme en comprend deux, par rapport à l'implémentation définitive :

- lorsque l'utilisateur clique sur le bouton ''Contractuelle'', il doit remplir un formulaire pour connaître les dates de la période de tests,

- une fois les statistiques de la plage horaire contractuelle affichées, fonctionnalité propose les options de formatage en PDF et en XML.

La correction de ces erreurs n'impliquent pas une refonte globale de la fonctionnalité. C'est pourquoi, Je ne les ai pas corrigées car l'analyse a pour but d'aider au développement, elle ne doit pas nécessairement être une réplique exacte de celui-ci.

ii. La prise en compte du modèle MVC

Le langage UML présente un avantage pour mettre en valeur les interactions entre les différentes parties du modèle MVC grâce au diagramme de séquence. Ce diagramme présente les différentes interactions de façon séquentiel, ainsi les développeurs peuvent suivre le déroulement d'une fonctionnalité. Il permet aussi de visualiser les données requises et transmises par chaque fonction de l'application.

Dans mon application, je fais appel à plusieurs bases de données qui ont chacune un certain nombre de tables. J'ai préféré ressembler toutes les tables par bases de données afin de gagner en lisibilité, plutôt que d'avoir une vingtaine de tables sur un même diagramme.

Ci-après, nous avons l'un de ces diagrammes : Il correspond à la fonctionnalité d'afficher les statistiques par hôtes avec une plage horaire personnalisée. Les autres diagrammes ressemblent globalement à celui-là, c'est pourquoi je n'en présente qu'un seul.

22

Page 23: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

23

Administrateur Vue Contrôleur Équipements

Charger_hotes( ) : Vector

Charger_Equip( ) : Vector

Charger_Nagios( ) : Vector

Charger_CustomerF( ) : Vector

Nagios Customer First

Aff icher_ecran1( Vector )

Valider( )

Ctrl_selec_hote (Vector) : Boolean

Charger_Equip( Vector ) : Vector

Charger_Nagios( Vector ) : Vector

Charger_CustomerF( Vector ) : Vector

Calculer_stat_hote ( ) : Vector

Ctrl_selec_hote (Vector) : Boolean

Aff icher_ecran2( )

Non_contract ( )Aff icher_ecran3( int )

Personnalise( )

Aff icher_ecran3( int )

Valider( )

Ctrl_selec_plan (Vector) : Boolean Ctrl_selec_plan (Vector) : Boolean

Aff icher_ecran4( Vector )

Diagramme de séquenceAfficher les statistiques par hôte

Page 24: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Le déroulement de ce diagramme peut être découpé en trois phases :

Au début, l'utilisateur vient de cliquer sur le bouton pour entrer dans ce cas d'utilisation. Il n'apparaît pas ici, puisqu'il ne fait pas partie du cas d'utilisation. A ce moment là, l'application fait appel à toutes les couches pour afficher l'ensemble des hôtes. C'est la fonction ''Charger_hotes() : Vector'' qui en est à l'initiative. ''Vector'' signifie qu'un tableau de type ''Vector'' sera retourné par cette fonction. Il contiendra l'ensemble des données récupérées par la fonction.

Une fois les hôtes chargés, l'utilisateur doit choisir les hôtes dont il souhaite avoir les statistiques et valident. La couche ''Vue'' récupère les sélections et les transmet à la couche ''Contrôleur'' pour vérifier si les sélections sont corrects à l'aide de la fonction ''Ctrl_select_hote( Vector ) : Boolean''.Si le booléen retourné est vrai alors la sélection est bonne et l'application charge l'écran 2.

Ensuite, l'utilisateur affine le type de plage horaire qu'il souhaite utiliser pour les calculs des statistiques et valide. Pour valider les informations données par l'utilisateur, la couche ''Vue'' les transmet à la couche ''Contrôleur'' grâce à la fonction ''Ctrl_select_plan( Vector ) : Boolean''. Si les données sont correctes, la couche ''contrôleur'' récupère l'ensemble des données grâce aux ''Vector'' et calcule les statistiques à l'aide de la fonction ''Calculer_stat_hote() : Vector''. La couche ''Vue'' récupère les données et les affiche.

III.L'implémentation au travers du Zend Framework

A. L'affichage : le premier aperçu de l'application

La partie affichage est un point essentiel dans une application puisque c'est à travers elle que l'utilisateur appréhende ou non son utilisation. Elle doit être avant tout claire et intuitive afin que l'utilisateur prenne l'application en main sans peine. Pour un site Web, il existe un certain nombre de standard dans l'organisation de la page. Ils dépendent à la fois du pays et aussi du type d'utilisateur final. La plus courante présente un bandeau en haut - sur lequel il peut y avoir le titre du site , un menu à gauche, et enfin le contenu du site sur le reste de la page. J'ai opté pour cette solution car le thème de mon site doit mettre en avant l'efficacité par rapport à la créativité. Le bandeau du haut rappelle le titre de la partie où se trouve l'utilisateur. Le menu présente les fonctionnalités du site. Et au centre, nous avons le titre de l'écran lorsqu'il est justifié, puis le contenu proprement dit.

J'ai commencé cette partie assez tôt de manière à avoir une présentation claire pour les jeux d'essai du reste du développement. La structure du site et sa présentation ont été écrites grâce à des balises de structures 'div' et dans une feuille de présentation CSS. Cette séparation, entre le code HTML de la page et la présentation, permet d'automatiser certaines normes graphiques propre au site et ainsi d'alléger grandement le travail des développeurs. De même, elle rend la maintenance du site plus aisée. J'ai veillé à ce que l'intégralité de mon site soit validé aux normes du W3C (World Wide Web Consortium), garantissant un code juste et dans les normes de qualité internet. De même, le site est compatible avec Mozilla Firefox 1.6 et supérieur et Internet Explorer 6.0 et supérieur. L'intégralité du site fonctionne aussi sous Opera et supérieur, excepté les fonctionnalités de formatage XML et PDF. De cette façon, mon site Web remplit, en grande partie, sa fonction d'accessibilité.

Une importante partie de la présentation est un ensemble de formulaires afin de définir la volonté de l'utilisateur. C'est pourquoi, le cheminement des écrans est assez linéaire.

24

Page 25: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Tout d'abord, nous avons l'écran d'accueil :

Le menu du bas n'est pas présent, dans la version définitive du site. Je l'ai présenter ici pour montrer les différences de tons et de couleurs lorsque le curseur passe sur les différents objets du menu. Cette méthode est valable pour un grand nombre de boutons de mon application.

Puis nous avons les écrans des formulaires. Je ne présente ici qu'un seul cheminement ( celui de la plage horaire personnalisée ) puisque seul l'écran de la plage horaire change. Dans la version contractuelle, seules la date du début de période et de fin de période sont présentées. Les heures sont récupérées dans ma base de données.

Le premier écran consiste à sélectionner les hôtes pour lesquels on souhaite avoir leurs statistiques. Le surlignement blanc permet de mieux voir quelle ligne on va sélectionner. Sur l'image, le curseur n'apparaît pas mais il se trouve sur la dernière ligne du tableau. Si l'utilisateur ne sélectionne aucun hôte, le même écran sera réaffiché avec un message d'erreur.

25

Page 26: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Au deuxième écran, l'utilisateur doit choisir quel type de plage horaire il souhaite utiliser pour le calcul des statistiques. La plage horaire personnalisée lui permet de définir avec exactitude la plage horaire alors que la plage horaire contractuelle s'appuie sur ma base de donnée pour recueillir les horaires journaliers à prendre en compte et les jours chômés à éviter.

Dans le troisième écran, l'utilisateur définit sa plage horaire. S'il choisit '' 24 heures sur 24 '' , l'heure de début et de fin de période ne sera pas pris en comptes. De même, s'il sélectionne '' Personnalisé '', et qu'il saisit deux heures identiques, l'application considérera l'horaire comme un horaire 24 heures sur 24. En cas de mauvaise saisie, l'écran sera réaffiché avec un message d'erreur.

26

Page 27: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Enfin, le dernier écran présente les statistiques. Le surlignement a été gardé pour faciliter leur repérage. De plus, j'ai choisi d'afficher les statistiques en rouge, noir ou vert selon qu'elles sont critiques, moyennes ou bonnes. Si l'application n'a pas pu calculer de statistiques pour une quelconque raison, le résultat sera des points d'interrogations rouges.

27

Page 28: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

L'icône PDF, en bas à gauche de l'écran, permet de convertir le tableau de statistiques en fichier PDF. Le logiciel Acrobat Reader se lance alors avec ce fichier, directement dans l'explorateur. L'utilisateur n'a plus qu'à en faire une sauvegarde, s'il le souhaite. Il en est de même pour l'icône de l'XML.Voici une partie du rendu de la page en PDF :

Voici une partie du rendu de la même page en XML :

28

Page 29: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Le plus ( + ) au niveau de la balise ''<table>'' signifie que l'information contenue dans ces balises n'est pas affichée. Ceci correspond à la même normalisation de l'arborescence des fichiers et dossiers.

Pour l'instant, le menu donne accès qu'à une seule fonctionnalité : celle de présenter les statistiques de disponibilité.L'onglet ''Organisme'' montre comment agencer d'autres fonctionnalités à mon site.

B. L'implémentation avec le Zend Framework

Si la partie vue du site est assez simple à réaliser, il en est tout autrement pour la partie contrôleur. En effet, une grande partie du développement se situe dans l'utilisation du Zend Framework et dans la mise au point du calcul des statistiques.

i. Le fichier boot strap

Le boot strap est un fichier qui est chargé à chaque changement de page. Il permet de charger les parties utiles du framework afin que le serveur Web puisse interpréter le reste du code.Dans le Zend Framework, le boot strap est placé à la racine du site par convention,. Pour comprendre comment il a été écrit, nous allons le découper en plusieurs parties afin de mieux les commenter.

Un fichier PHP peut contenir du code PHP, mais aussi d'autres langages comme de l'HTML. Pour délimiter la partie du code PHP du reste, le code PHP doit être écrit dans la balise <?php ... ?>. Une fois notre balise ouverte, nous pouvons commencer à écrire en PHP.

Avant toute chose, il est conseillé de définir l'affichage des erreurs PHP et le repère horaire de la zone du serveur.

<?phperror_reporting(E_ALL|E_STRICT) ;date_default_timezone_set('Europe/Paris') ;

Lorsque le serveur arrive sur ce fichier, il ne connaît toujours pas l'arborescence de notre projet. La définition de l'arborescence se fait à l'aide de la fonction set_include_path (). Il faut lui passer en paramètre le chemin des principaux dossiers de notre application.

Une fois que les chemins sont définis, nous pouvons récupérer le code PHP du fichier ''Loader.php'' qui se trouve dans le dossier de Zend. Ce code permet d'utiliser la classe ''Zend_Loader'' qui nous sera utile pour charger proprement les classes du Zend Framework dont nous avons besoin.

// Définitions des différents répertoires du projetset_include_path('.' . PATH_SEPARATOR . './library'

. PATH_SEPARATOR . './application/models/'

. PATH_SEPARATOR . get_include_path());

include "Zend/Loader.php" ;

29

Page 30: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Pour charger une classe, nous devons utiliser la fonction loadClass(). Nous devons lui passer en paramètre le nom de la classe à charger. Pour trouver le fichier de la classe, la fonction remplace les tirais bas ( _ ) par des slashs ( / ) et ajoute un '' .php '' à la fin. Par exemple, le chemin du fichier de la classe '' Zend_Config_Ini '' est '' Zend/Config/Ini.php''.Cette convention permet de retrouver rapidement les fichier des classes à charger.Une fois nos classes chargées, on peut démarrer une session (au besoin) et lancer la classe ''Controller'' qui a été appelé en créant un objet Zend_Controller_Front et en lançant l'application grâce à sa fonction dispatch().

// Chargement des classesZend_Loader::loadClass('Zend_Config_Ini') ;Zend_Loader::loadClass('Zend_Controller_Front') ;(...)Zend_Loader::loadClass('Zend_Session');Zend_Loader::loadClass('Zend_View');

Zend_Session::start();

//Initialisation du programme$frontController = Zend_Controller_Front::getInstance() ;$frontController->throwExceptions(true) ;$frontController

->setControllerDirectory('./application/controllers') ;$frontController->dispatch() ;

Le fichier boot strap s'arrête ici. Notons que nous n'avons pas besoin de fermer la balise du code PHP par '' ?> '' car la fonction $frontController->dispatch() aura pour effet de quitter cette page de code pour lancer une autre page. Ainsi, l'application ne lira jamais ce qu'il y a en dessous de cette fonction. Ceci est valable pour d'autres fichiers de l'application comme les contrôleurs qui lancent leurs pages de vues.

ii. Les contrôleurs

Les contrôleurs sont essentiels dans notre application puisque c'est eux qui ont la charge de valider ou non les commandes et les saisies de l'utilisateur. Lors de mon analyse, j'ai pu identifier un certain nombre de fonctions comme nous l'avons. A ce moment-là, je ne savais pas comment fonctionnait le Zend Framework. Certains de ces mécanismes m'ont contraint à adapter mon analyse à ce framework : par exemple, ma fonction ''charger_hotes()'' du diagramme de séquence se traduit par une partie de l'action ''hoteAction'' du contrôleur ''StatistiqueController''. Et en fonction de la page où se trouvait l'utilisateur, l'action renverra telles ou telles données à la vue, mais pas nécessairement sous la forme d'un seul ''Vector'' comme je l'avais mentionné.

Mon analyse reste valable dans les transitions qu'opère mon application entre les différentes couches du modèle MVC et dans les contrôles à réaliser.

30

Page 31: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Pour avoir une idée de l'organisation du dossier des contrôleurs, voici son arborescence :

Tous les contrôleurs sont répertoriés dans le dossier ''controllers''.

Le contrôleur ''IndexController'' est celui de la page d'accueil du site.

Le contrôleur ''StatistiquesController'' contient toutes les actions et contrôles relatifs aux statistiques.

Afin de voir concrètement comment j'ai adapté mon analyse au Zend Framework, nous allons détailler le code de l'action ''hoteAction'' du contrôleur ''StatistiquesController'' :

a) Architecture principale de l'action ''hoteAction''

Cette action permet de contrôler l'ensemble des informations provenant des pages des statistiques des hôtes. Cet ensemble de pages forme un formulaire permettant de définir la volonté de l'utilisateur. Au niveau du contrôleur, nous devons donc trouver un moyen pour garder en mémoire les choix de l'utilisateur pour pouvoir les réutiliser lors du calcul et de l'affichage des statistiques.

Dans la programmation orientée objet, les objets peuvent prendre des attributs qui définissent leurs états (par exemple, la vitesse pour une voiture). J'ai essayé de créer un attribut pour chaque donnée dont j'avais besoin dans la classe qui contient mon action, à savoir ''StatistiquesController''. Cette méthode n'a pas fonctionné comme je l'espérais : les données antérieurs étaient perdues lors des changements de pages.

J'ai donc dû me documenter sur le Zend framework pour trouver un moyen de résoudre ce problème. J'avais trouvé une partie de la solution lorsque j'ai pensé à utiliser les variables de session. Dans PHP, il est possible de définir des variables de sessions qui gardent leurs valeurs lors des changements de pages. Inclure directement cette solution dans mon programme n'aurait pas été très propre car ces variables auraient été visibles par tous les contrôleurs, introduisant ainsi des problèmes de nommage et de lisibilité du code. En approfondissant mes recherches, j'ai trouvé la classe du framework qui permet de gérer des variables de sessions. Cette classe est Zend_Session_Namespace.

Pour l'utiliser, il faut simplement charger la classe Zend_Session dans le boot strap, démarrer une session grâce à la fonction Zend_Session::start(), créer un objet du type Zend_Session_Namespace et y ajouter ce que l'on souhaite en mettant les valeurs comme attributs. Par exemple, dans mon application, je dois garder en mémoire les identifiants des hôtes que l'utilisateur a sélectionné pour pouvoir calculer leurs statistiques. Comme nous ne savons pas combien d'hôtes l'utilisateur va sélectionner, il est plus judicieux d'utiliser un tableau que des variables pour chaque hôte. J'ai décidé d'appeler ce tableau ''$stats''. Pour l'enregistrer dans l'espace de session $espaceSession, il faut faire :

$espaceSession->stats = $stats ;

L'espace de session $espaceSession prendra alors la valeur de $stats en attribut.

Comme l'action ''hoteAction'' s'occupe de plusieurs pages, un autre problème se pose : il faut pouvoir distinguer chacune de ces pages pour pouvoir effectuer leurs contrôles correspondant et pour pouvoir les lancer.

31

Page 32: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

L'ensemble des pages sont des formulaires, c'est à dire que nous devons récupérer les valeurs saisies par l'utilisateur avant de contrôler ou d'afficher l'écran suivant. Grâce à ce principe, j'ai résolu le problème en incluant, dans mes pages HTML, une balise spéciale qui contiendra le numéro de la prochaine étape du formulaire à afficher.Cette balise est la balise <input type="hidden" ... >. Elle est invisible à l'affichage comme nous l'indique son type. Voici comme je l'ai déclarée dans la première étape du formulaire.

<div><input type="hidden" id="etape" name="etape" value="2" />

</div>

( La balise est intercalée dans une balise de structure ''<div>'' pour plus de lisibilité dans le code, mais ceci n'est pas obligatoire. )

Je lui affecte un nom grâce à ''name''et la valeur de la prochaine étape grâce à ''value'', ainsi je pourrai l'appeler et récupérer sa valeur lorsque le formulaire sera envoyé au serveur.Une fois la valeur récupérée, il ne reste plus qu'à tester la valeur de la variable pour déterminer quelle est la prochaine étape à afficher.

En algorithme, la structure principale de l'action est donc :

fonction hoteAction()Début

Si l'action provient d'un formulaire Alors :

monEtape = etape du formulaire ;

Si ( monEtape == 2 ) Alors :

Contrôle pour l'étape 2 ;

Fin SiSi ( monEtape == 3 ) Alors :

Contrôle pour l'étape 3 ;Fin SiSi ( monEtape == 4 ) Alors :

Contrôle pour l'étape 4 ;Fin SiSi ( monEtape == pdf ) Alors :

Contrôle pour l'étape du document PDF ;

Fin SiSi ( monEtape == xml ) Alors :

Contrôle pour l'étape du document XML ;

Fin SiSinon

monEtape = 1 ;Contrôle pour la première étape ;

Fin SiAffichage() ;

Fin

32

Page 33: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

On peut remarquer ci-dessus, les options de formatage sont au même niveau que les étapes du formulaire puisque je contrôle leur accès au même moment. Ceci est fait pour rendre le code plus lisible et même chronologiquement cette solution se tient puisque ces options sont réalisées après l'étape 4. Elles sont équivalentes à une cinquième étape, qui aurait différents affichages selon que l'utilisateur décide de formater la page en XML ou en PDF.

Enfin lorsque tous les contrôles sont réalisés et que les variables ont été passées à la vue, on l'affiche avec la fonction ''Affichage()''.

Concrètement, voici comment sont implémentées les différentes parties de cet algorithme, avec le Zend Framework :

Le premier contrôle (celui du formulaire) est implémenté en utilisant la fonction isPost(). Elle renvoie un booléen à vrai si la requête est un ''Post'', c'est à dire une requête provenant d'un formulaire :

// Si les données proviennent d'un formulaire Alorsif ( $this->_request->isPost() ){

(...)}

Si c'est le cas, l'application exécutera ce qui sera entre accolades ( { ... } ).

La récupération d'une valeur d'une balise d'un formulaire passe par l'utilisation d'un filtre. Celui-ci a pour but de pré-formater la valeur dans le but de supprimer les caractères illégaux tels que des slashs ( / ) ou des chevrons ( < > ) . Dans mon application, j'utilise le filtre du Zend Framework ( $filter ) grâce à la fonction $filter->filter() et un filtre de PHP grâce à la fonction trim(). La récupération de la valeur brute de la variable se fait par la fonction getPost() du controleur courant.

L'implémentation complète est le code suivant :

// Chargement de la classeZend_Loader::loadClass('Zend_Filter_StripTags');// Création de l'objet filtre$filter = new Zend_Filter_StripTags() ;

// Récupération de la variable "etape" pour connaître la page à // afficher$etape = trim($filter->filter

($this->_request->getPost('etape'))) ;

Enfin, les conditions sont celles du code PHP : si nous voulons tester si notre variable $etape est égale à deux, le teste d'égalité s'écrira :

if ($etape == "2" ){

(...)}

Nous faisons de même pour les autres boucles conditionnelles.

33

Page 34: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Les premiers contrôles des étapes consistent à vérifier si les données reçues sont correctes. Dans ce cas-ci, l'application prépare les données pour la prochaine étape, sinon elle recharge la même.

b) Aperçu d'une des fonctions de calcul des statistiques

Maintenant que nous avons vu l'architecture globale de la fonction, analysons le processus de la dernière étape – celui qui permet de calculer les statistiques.

Pour calculer les statistiques, il faut préalablement vérifier plusieurs éléments.

Le premier des éléments à connaître est le type de plage horaire que l'utilisateur a précédemment sélectionné. En effet si l'utilisateur sélectionne une plage horaire contractuelle, un certain nombre de ses informations seront récupérées sur la base de données. Alors que si l'utilisateur a sélectionné la plage horaire personnalisée, toutes ses informations seront récupérées à partir du formulaire. C'est pourquoi, la fonction qui calcule les statistiques est divisée en deux versions – une pour chaque type de plages horaires.

Ensuite, nous devons savoir si les informations saisies par l'utilisateur sont correctes et calculer les statistiques si nécessaire. C'est dans cette fonction qu'intervient la partie qui permet de calculer les statistiques.

Je vais détailler la version de la plage horaire contractuelle car c'est la plus intéressante des deux, puisqu'elle fait appel à la base de données réalisée. La fonction s'appelle ''hote_form22()'' car elle est utile pour l'action ''hoteAction'' et elle valide la deuxième version du deuxième formulaire que l'utilisateur doit saisir.

Voici le début de la fonction :

private function hote_form22($espaceSession){

$formvalide = true ;

Zend_Loader::loadClass('Zend_Filter_StripTags');$filter = new Zend_Filter_StripTags() ;

// Récupération des variables du formulaire// --- Récupération de la date de début$jdeb = $filter->filter($this->_request->getPost("jdeb")) ;$mdeb = $filter->filter($this->_request->getPost("mdeb")) ;$adeb = $filter->filter($this->_request->getPost("adeb")) ;

$datedeb = $jdeb . '/' . $mdeb . '/' . $adeb ;$espaceSession->datedeb = $datedeb ;

// --- Récupération de la date de fin$jfin = $filter->filter($this->_request->getPost("jfin")) ;$mfin = $filter->filter($this->_request->getPost("mfin")) ;$afin = $filter->filter($this->_request->getPost("afin")) ;

$datefin = $jfin . '/' . $mfin . '/' . $afin ;$espaceSession->datefin = $datefin ;

34

Page 35: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Dans cette partie, l'application initialise un variable booléenne et récupère les données du formulaire par l'intermédaire du filtre $filter. Elle formate aussi les dates et les enregistre dans l'espace de session, pour pouvoir les réutiliser plus tard.

Maintenant, nous pouvons contrôler la saisie de l'utilisateur :

// Si un des champs est vide ou si les dates ne sont pas // valides :if ( $jdeb == '' || $mdeb == '' || $adeb == '' ||

$jfin == '' || $mfin == '' || $afin == '' || !Zend_Date::isDate($datedeb) || !Zend_Date::isDate($datefin) )

{// Le booléan de validité du formulaire passe à faux$formvalide = false ;

}

Nous contrôlons si tous champs ont été remplis et si les dates de début et fin de période sont correctes. Pour cela, nous utilisons une fonction statique du Zend Framework qui s'appelle Zend_Date::isDate(). Elle teste si $datedeb et $datefin sont des dates valides. Cette fonction prend en compte tous les contrôles possibles sur la validité d'une date comme le test du numéro du jour du mois de Février pour les années bissextiles. Comme nous voulons l'inverse, il faut ajouter un point d'exclamation devant l'appel de la fonction. Ceci aura pour effet d'inverser la valeur booléenne retournée par la fonction. Ainsi si la date est fausse, la valeur booléenne finale sera ''vrai''.Si le formulaire n'est pas valide, nous plaçons notre variable booléenne $formvalide à faux.Sinon, nous calculons les statistiques.

Pour réaliser ce calcul, nous devons connaître les hôtes qui ont été sélectionnés par l'utilisateur. Nous avons ces données grâce au tableau de la variable de session nommé hotes[]. Ce tableau contient les valeurs de leur identifiant.Si nous récupérons une valeur du tableau, nous pouvons calculer les statistiques pour un hôte. Nous enregistrerons cette données dans un tableau pour pouvoir retrouver toutes les statistiques par la suite. Ensuite, nous pouvons passer à l'hôte suivant et ainsi de suite jusqu'à ce qu'il n'y est plus d'enregistrements dans le tableau hotes[].

Nous avons réduit notre problème au calcul des statistiques pour un seul hôte. Pour réaliser ce calcul, nous devons récupérer les données concernant l'hôte telles

que sa plage horaire et l'identifiant coté Nagios. Grâce à cet identifiant, nous récupérons les données de l'hôte coté Nagios.

Lorsque toutes les données sur un hôte sont aquises, nous pouvons commencer la boucle de calcul des statistiques. Nous devons comptabiliser le nombre total de tests effectués et le nombre de fois que l'hôte est en ligne. Ainsi, nous n'aurons plus qu'à faire une division entre ces deux variables pour avoir le ratio de disponibilité de l'hôte. En multipliant par 100, nous en obtiendrons le pourcentage.

Pour que notre statistique soit juste, nous devons veiller à ce que :

- l'heure du test soit entre l'heure de début et l'heure de fin- la date de test soit entre la date de début de début et de fin de période- la date de test ne soit pas égal à un jour chômé

35

Page 36: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Nous devons d'abord récupérer les informations du test en cours de validité pour pouvoir les tester après :

$heurefor = date('H', strtotime($val['end_time'])) ;$minfor = date('i', strtotime($val['end_time'])) ;$secfor = date('s', strtotime($val['end_time'])) ;

$afor = date('Y', strtotime($val['end_time'])) ;$mfor = date('m', strtotime($val['end_time'])) ;$jfor = date('d', strtotime($val['end_time'])) ;$datefor = mktime(0,0,0,$mfor,$jfor,$afor) ;

Le premier test à effectuer serait le cas le plus large, c'est à dire un test sur l'année ou le mois. Mais comme on peut réaliser les tests de dates dans leur globalité ( c'est à dire en prenant en compte leur année, mois et jour ) il est plus lisible de les regrouper.C'est pourquoi, nous testons si la date du test est un jour chômé. De cette manière, nous enregistrons le résultat dans une variable booléenne que nous placerons avec les autres tests de dates.

// Test pour les jours chômés contractuels$testjourchaume = false ;foreach ($result2 as $key => $val2){

if ( $val2['Jour'] == $jfor && $val2['Mois'] == $mfor ){

$testjourchaume = true ;}

}

La variable $result2 correspond au tableau contenant l'ensemble des jours chômés pour l'équipement en cours. $val2 contient toute la ligne courante de ce tableau. Pour accéder à une valeur d'une colonne, il faut ajouter son nom entre cote simple ( '...' ) et entre crochet ( [...] ).

Dans leur format initial, les dates sont longues à comparer ( l'année, le mois , le jour ... ) . C'est pourquoi, il est préférable de les convertir en nombre de secondes depuis une date antérieure. De cette façon, seul un test suffit pour comparer deux dates, puisque nous manipulons des valeurs entières.

C'est la fonction ''mktime()'' qui permet de faire cette conversion : elle convertit les dates en nombre de secondes depuis le 1ier Janvier 1970 (date marquant le début de l'époque de UNIX).Cette date de départ nous convient parfaitement pour notre application puisque l'utilisation de Nagios au sein du SIL est supérieure à cette date. Ainsi l'application n'aura jamais à traiter de cas antérieurs, même pour les données archivées.Comme nous le voyons ci-dessous, nous testons simplement si l'entier $datefor est compris entre $datedeb et $datefin, puis nous ajoutons le booléen du test précédent.

$testheure = false ;// Si la date du test Nagios est dans l'intervalle demandé et si le // jour n'est pas chôméif ( $datedeb <= $datefor && $datefor <= $datefin &&

$testjourchaume == false){

36

Page 37: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

A l'intérieur de cette boucle vient les tests des heures. Trois cas sont répertoriés :

Le premier cas est si l'heure de début ($heuredeb) est égale à l'heure de fin ($heurefin), nous considérons que l'horaire est de 24 heures sur 24. Il est plus logique d'opter pour cette solution que l'inverse car l'intervalle se réduirait en un point. De plus nous n'aurons aucun moyen d'exprimer clairement un horaire de 24 heures sur 24. Le booléen du test des heures passe donc à vrai :

// Si l'heure du début est égale à l'heure de fin, on considère // le planning horaire comme totalif ($heuredeb == $heurefin){

$testheure = true ;}

Le deuxième cas est si l'heure de début ($heuredeb) est inferieure à l'heure de fin ($heurefin). Nous sommes dans un cas normal d'utilisation.

// Si l'heure de début est inférieur à l'heure de fin, on teste // l'heure normalementif ($heuredeb < $heurefin){

// et Si l'heure du test est dans l'intervalleif ($heuredeb <= $heurefor && ( $heurefor < $heurefin ||

($heurefor == $heurefin && $minfor == 0 && $secfor == 0) )){

$testheure = true ;}

}

Le troisième et dernier cas est le plus délicat. Il suppose que l'heure de début ($heuredeb) est supérieure à l'heure de fin ($heurefin). Ce cas arrive si l'utilisateur souhaite avoir un horaire à cheval entre deux jours ( par exemple de 23 heures à 2 heures du matin ). Pour que notre test soit correct nous devons rajouter cette différence dans les heures. En d'autres termes, nous devons rajouter 24 heures à l'heure de fin et à l'heure du test de Nagios, si celle-ci est comprise entre 0 et l'heure de fin.

// Si l'heure du début est supperieur à l'heure de fin, on gère // le modulo des heures avant les testsif ($heuredeb > $heurefin){

if (0 <= $heurefor && $heurefor <= $heurefin ){

$heurefor = $heurefor + 24 ;}$heurefin = $heurefin + 24 ;if ( $heuredeb <= $heurefor && ( $heurefor < $heurefin

|| ($heurefor == $heurefin && $minfor == 0 && $secfor == 0) )){

$testheure = true ;}

}

37

Page 38: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Maintenant que tous les tests concernant les heures sont effectués, nous devons savoir si l'hôte a été en ligne ou non pour ce test. Pour cela, nous devons tester si la colonne ''state'' est égale à 0. Mais ce n'est pas tout. En effet, si nous lisons la documentation de Nagios, nous nous apercevons qu'une autre colonne est à prendre en considération. Celle-ci se nomme ''is_raw_check''. Pour connaître sont importance nous devons connaître le fonctionnement de Nagios. Lorsqu'il réalise un test sur une machine du réseau afin de connaître son état, il reçoit un code d'état semblable au code d'état des services. C'est le ''raw check''. Nagios doit réaliser des opérations supplémentaires afin de connaître l'état réel de l'hôte.C'est pourquoi, nous devons éliminer les cas où nous sommes dans un ''raw check'', pour ne garder que les états certains des hôtes.

// Si le test des heures est réussiif ($testheure){

$state = $val['state'] ;$is_raw_check = $val['is_raw_check'] ;

// Si "is_raw_check" = 0 pour connaître l'état réelif ($is_raw_check == 0 ){

// Si son état est OKif ( $state == 0 ){

// on incrémente le compteur de réussites$compteurreussi= $compteurreussi + 1 ;

}// On incrémente le compteur total$compteurtotal= $compteurtotal+ 1 ;

}}

( La variable $val est la ligne courante du tableau contenant l'ensemble des tests de Nagios sur l'équipement en cours )

Suite à cela, nous regardons si les compteurs ont une valeur nulle. Si le compteur de tests total valide ($compteurtotal) est différent de 0 cela signifie qu'au moins un test correspondait aux attentes de l'utilisateur. Nous pouvons calculer les statistiques pour l'hôte en cours, que nous enregistrons dans la variable de session. Dans le cas contraire, aucune ligne de tests de Nagios ne correspondait aux demandes de l'utilisateur. J'ai choisi de renvoyer des point d'interrogation en valeur pour alerter l'utilisateur. Le code qui correspond à cette étape n'est pas difficile en soi, j'ai donc choisi de ne pas le faire figurer.

Si nous reprenons le modèle MVC, nous remarquons qu'une fois l'ensemble des contrôles effectuer, la couche de contrôle passe des données à la couche d'affichage. Pour réaliser cela avec le Zend Framework, nous devons réaliser cette opértion dans le contrôleur.Il faut simplement déclarer la variable qui prendra effet dans la vue en lui affectant une valeur. Si la variable est par exemple le tableau des statistiques ($stats), voici la synthaxe pour le passer à la vue.

// Envoie des statistiques à la vue$this->view->stats = $stats ;

Par $this, nous faisons appel à l'objet qui contient ce code, c'est à dire le contrôleur. Cette syntaxe est équivalente à dire que nous déclarons la variable stats dans la vue du contrôleur et que nous lui affectons la valeur de variable $stats.

38

Page 39: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Si nous voulons récupérer la variable de la vue dans une nouvelle variable $stats, la syntaxe sera la suivante :

$stats = $this->stats ;

$stats prendra la valeur de la variable stats de l'objet qui contiendra ce code, c'est à dire la vue.

Sur cette partie, il n'a pas été facile de respecter le concept du modèle MVC. En effet, la base de données de Customer First est une base de données en Microsoft SQL Server, contrairement aux deux autres bases de données qui sont en MySQL. Ceci posa un problème puisque le Zend Framework propose des fonctions pour créer des requêtes pour ces deux langages via un PDO ou PHP Data Object. Ceci est une interface d'abstraction pour accéder aux bases de données, ce qui permet d'utiliser le même code pour accéder aux bases de données.Or je n'ai pas trouvé de PDO pour Microsoft SQL Server fonctionnant sous Linux. Je n'ai donc pas pu utilisé la fonctionnalité du Zend Framework pour cette base de données, et j'ai été contraint d'écrire moi-même le code PHP et SQL. Au début du développement, je ne savais pas passer des données brutes de Microsoft SQL Server à la vue. C'est pourquoi je réalisais la connexion de la base de données dans la partie contrôleur et la récupération des informations de la base de données se faisait dans la vue (ce qui est contraire au modèle MVC, puisque la vue doit toujours passer par le contrôleur pour accéder aux bases de données).Après plusieurs tests, j'ai trouvé le moyen d'enregistrer les informations utiles dans un tableau. J'ai donc pu résoudre ce problème et dans sa dernière version, mon application respecte le modèle MVC.

ii. Les vues

Après avoir vu comment sont implémentés les contrôleurs et comment il transmettent les données à la vue, nous allons passer à l'implantation des vues elles-mêmes.Voici l'arborescence de leur dossier :

Dans mon applisation, seul le dossier ''scripts'' est utilisé.

Il contient tous les éléments dont l'application a besoin pour afficher les vues.

Pour comprendre comment a été construite cette partie, il faut savoir comment est créé un site Web :

Les sites Web comprennent généralement un haut de page. Celui contient la balise <head> qui permet de définir le titre, les mots clé auxquels doit être rattacher le site. Puis à l'intérieur d'une balise <body>, nous avons la page Web en elle-même. Sa structure et son contenu sont alors écrits de haut vers le bas et de gauche à droite. Ainsi, si le site Web a un menu à gauche comme le mien, le code pour ce menu sera défini avant le contenu de la page.

39

Page 40: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Comme la structure d'un site varie généralement peu de page à page, certaines parties de codes seront réutilisées, comme par exemple le code du menu. Cependant un programme propre doit éviter les doublons. C'est dans cet esprit de factorisation que la notion de templates apparaît. Les templates de pages HTML sont des morceaux de pages qui peuvent appeler ou être appelés par d'autres templates.J'ai séparé mes pages en trois templates :

Le premier template est le template du haut du code de la page Web, il comprend le début de la balise <html> ( qui englobe toutes les balises ) la balise <head>, le menu la barre de titre, puis l'ouverture de la balise du contenu de la page web. Sur l'arborescence c'est le fichier ''header.phtml''.

Le deuxième template est le template du contenu de la page web. Il contient l'essentiel des informations que la page doit transmettre.

Enfin, le troisième template est le template du bas du code HTML de la page. Il ferme la balise du contenu et d'autres balises. Il correspond au fichier ''footer.phtml'' sur l'arborescence.

Comme nous l'avons vu l'action ''indexAction'' du contrôleur ''IndexController'' lance la page d'accueil du site et l'action ''hoteAction'' du contrôleur ''StatistiquesController'' lance les pages relatifs aux statistiques des hôtes. Ainsi la page d'accueil aura un template qui lui sera associé ainsi que les pages des statistiques des hôtes.

Pour ce dernier cas, il faut donc faire cohabiter plusieurs affichages dans un même fichier (nommé ''hote.phtml''). Pour savoir lequel il faut charger, nous devons nous servir de la variable $this->etape qui contient le numéro ou le nom de l'étape à afficher.Pour les pages HTML, nous aurons l'appel du template du haut du code de la page HTML, puis les tests pour savoir quel contenu charger. Une fois ces tests finis, nous devons rajouter l'appel du bas du code de nos pages HTML.Ceci diffèrent de l'analyse UML que j'ai élaboré précédemment, puisque ce ne sont pas plusieurs fonctions qui sont responsables de l'affichage de plusieurs écrans mais une vue qui est responsable de plusieurs écran.De même, pour des soucis de factorisation de code, le troisième écran du formulaire ( celui où l'utilisateur saisie sa plage horaire personnalisée ou contractuelle ) correspond au même cas.

En effet, ceci est possible car des deux écrans, le seul changement que nous pouvons noter c'est la présence ou non de la saisie de l'horaire. Pour traiter ce cas, j'ai créé une variable pour enregistrer quel type de formulaire l'utilisateur avait choisi. L'application teste cette variable et si elle correspond au formulaire de la plage horaire personnalisée, elle affiche la partie pour saisir l'horaire, sinon elle saute cette étape.

Enfin, pour différencier cette partie des parties PDF et XML, l'application teste si $this->etape est égale à 1, 2, 3 ou 4. Si nous sommes dans l'un de ces cas, l'application exécutera le code des pages HTML expliqué précédemment.Les parties PDF et XML sont chargées par l'application si $this->etape est égale à ''pdf'' ou à ''xml''.

40

Page 41: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

C. Les problèmes d'intégration

J'ai pu réaliser l'ensemble du site dans les temps. Il est donc utilisable par l'établissement. Malgré ces points positifs, un point négatif subsiste encore : la lourdeur de l'alimentation de ma base de données. En effet, même si elle est opérationnelle, il serait fastidieux de devoir enregistrer toutes les informations de tous les hôtes manuellement. C'est ce que j'ai essayé de résoudre les dernières semaines. En effet, même si j'ai pu rapidement mettre au point un algorithme, il lui manquait la normalisation qui lui permettrait de fonctionner.

Si nous voulions automatiser l'alimentation de ma base de données, il aurait été nécessaire que l'algorithme puisse faire le lien entre les deux bases de données. Ce lien ne doit pas être pas dans ma base de données puisque mon algorithme est fait pour la mettre à jour. Il ne doit donc pas s'appuyer sur les données de la nouvelle base.Pour faire ce lien, il restait Nagios et Customer First. Pour une question de lisibilité, nous avons choisi Nagios.

Afin d'ajouter un libellé compréhensible, nous voulions rajouter, dans Nagios, une partie du nom des organismes aux libellés existants concernant les machines. Malheureusement cette solution s'est avérée difficile à appliquer pour prendre en compte l'ensemble des établissements. En effet, quelque soit la normalisation de noms, nous aurons un problème de distinction. Par exemple, si nous établissons de rajouter les quatre premiers caractères du libellé de Customer First, pour l'hôpital de Brive, nous devrons rajouter ''CH B'' à ses machines. Seulement, il existe peut être d'autres hôpitaux dans une ville dont le nom commence par la lettre ''B'' qui sont répertoriés dans Customer First. De plus, certains libellés sont entièrement écrits. Par exemple, pour une maison de retraite, le libellé commence par ''Maison de Retraite''. La solution serait peut être de prendre la première lettre de chaque mot, mais là encore, nous aurons les mêmes problèmes que précédemment.

Enfin, même si le développement de la mise à jour automatique arrive à son terme, les utilisateurs devront ajouter manuellement des informations dans ma base de données, car celle-ci à des informations qui ne sont ni dans Nagios, ni dans Customer First (comme le site géographique des hôtes). C'est pourquoi, quelque soit la solution adoptée, des informations devront être ajoutées manuellement.

41

Page 42: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Conclusion

Malgré des difficultés dû à la configuration de mon poste de travail et à l'utilisation d'un framework que je ne connaissais pas, j'ai pu réaliser cette application dans les temps. Elle sera sans doute utilisée au sein du SIL, jusqu'à ce que Nagios ou d'autres logiciels intègrent ces fonctionnalités.

Ce stage a été très enrichissant pour moi. J'ai pu y découvrir une nouvelle méthode de développement en PHP : la programmation orientée objet appliquée au Zend Framework.Je n'avais jamais pratiqué cette programmation avec le PHP et j'ai pu l'aborder avec un exemple concret et intéressant. De plus j'ai pu faire mes premiers pas dans le Zend Framework, comprendre ces normalisations et ses concepts. Et sachant que ce framework veut s'inscrire comme le standard en matière de développement PHP, c'est toujours une bonne chose de l'avoir abordé. Il m'a apporté satisfaction.

Ce stage m'a aussi apporté une véritable vision du monde de travail. Avant le stage, je croyais que le travail en entreprise était beaucoup plus strict que je ne l'ai vécu ou vu au sein du SIL. Certes, la situation n'est pas toujours aussi idéale à celle-ci, mais je suis persuadé que ce mode de fonctionnement n'est pas si rare dans les entreprises.

Enfin, même si ce stage a été une agréable approche du monde du travail, je souhaite continuer mes études en licence professionnelle. Ceci me permettra d'acquérir une spécialité dans un domaine que j'aime et d'obtenir une validité de mes études au niveau européen, m'offrant ainsi plus de possibilités pour ma vie active.

42

Page 43: Complément au logiciel de supervision '' Nagios ''maryjulie.free.fr/Legrand/Mémoire de stage/Memoire - Florian... · En effet, Nagios – logiciel de supervision de réseau utilisé

Sources documentaires

Document utilisateur :

ObjectLine, CustomerFirst – Data & View Definition

Sites internet :

http://akrabat.com

http://classes.scriptsphp.org

http://devzone.zend.com

http://framework.zend.com

http://fr.php.net

http://fr.wikipedia.org

http://nagios.org

http://remi.collet.free.fr

http://www.alsacreations.com

http://www.developpez.net

http://www.sil.fr

43