Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails

La page est créée Nadia Allain
 
CONTINUER À LIRE
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails
UNIVERSITE DES SCIENCES ET TECHNOLOGIES DE LILLE
               Master 1 informatique parcours Génie Mathématique et Informatique

    Réalisation d'une interface de gestion des
          utilisateurs en Ruby on Rails

                    Rapport de stage du 3 septembre au 5 octobre 2007

                            Société Esolys hébergé à Cré’Innov

Tuteur en entreprise : M. Jean-Sébastien Galloo

Rapport de stage réalisé par des étudiants en Master 1 GMI :
      Vincent Fretin
      Jérôme Maslak
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails
Remerciements

       Nous tenons à exprimer nos sincères remerciements à M. Denis Leroy, Conseiller
de Projets Emergents d'entreprise à Cré'Innov, qui nous a intégré avec gentillesse et bonne
humeur.

       Nous remercions particulièrement notre maitre de stage, M. Jean-Sébastien
Galloo, notre tuteur en entreprise et gérant d'Esolys, pour nous avoir fait confiance en ce
qui concerne l'implantation des solutions que nous proposions.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails
Table des matières
Introduction.......................................................................................................5
 1. Présentation de l'entreprise...........................................................................6
    1.1. Entreprise...................................................................................................................6
    1.2. Méthodes de travail...................................................................................................6
       1.2.1. Le développement incrémentiel.........................................................................6
       1.2.2. Le Pair Programming.........................................................................................6
       1.2.3. L'eXtreme programming....................................................................................7
       1.2.4. Subversion..........................................................................................................7
2. Présentation du sujet.....................................................................................8
    2.1. Le sujet......................................................................................................................8
    2.2. Choix de la technologie employée.............................................................................8
       2.2.1. Ruby...................................................................................................................8
       2.2.2. Rails...................................................................................................................8
3. Recherche des outils...................................................................................10
    3.1. Internationalisation..................................................................................................10
       3.1.1. Solutions existantes..........................................................................................10
       3.1.2. Solution retenue...............................................................................................10
    3.2. Génération automatique de formulaire....................................................................11
       3.2.1. Introduction......................................................................................................11
       3.2.2. Active Scaffold................................................................................................11
    3.3. Annuaire OpenLDAP..............................................................................................12
       3.3.1. Introduction......................................................................................................12
       3.3.2. Implantation.....................................................................................................13
    3.4. Fenêtres Ajax...........................................................................................................14
       3.4.1. Solution prévue................................................................................................14
       3.4.2. Solution finalement retenue.............................................................................14
4. Travail réalisé.............................................................................................15
    4.1. Fonctionnalités de l'application...............................................................................15
    4.2. Perspective d'évolutions..........................................................................................22
5. Déploiement...............................................................................................23
    5.1. Installation de Ruby + Rails + plugins....................................................................23
    5.2. Déploiement de l'application...................................................................................24
       5.2.1. Capistrano + Mongrel + Apache......................................................................24
       5.2.2. Documentation + Mongrel + Apache..............................................................24
Conclusion.......................................................................................................25
Conclusion Vincent.........................................................................................26
Conclusion Jérôme..........................................................................................27
Bibliographie...................................................................................................28
Annexes...........................................................................................................29
   Annexe 1 : Script d'installation........................................................................................30
   Annexe 2 : Documentation pour le déploiement.............................................................32
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails
Introduction
        Dans le cadre de notre année de M1, nous devions réaliser un stage d'un mois afin
de nous initier au monde de la recherche.
Notre stage s'est déroulé à Esolys hébergé au pré-incubateur de l'USTL Cré'Innov. Cette
organisation permet un accompagnement dans la démarche et l'étude des divers aspects
du projet du créateur d'entreprise avec l'université.
Esolys a pour mission de devenir un leader du développement avec Ruby on Rails sur la
région lilloise.

        Le stage consistait à développer une interface d'administration ergonomique de
type « Web 2.0 » pour une application web de gestion de la salle blanche de l'IEMN
(Institut d'Electronique de Microélectronique et de Nanotechnologie).
Une salle blanche est une pièce ou une série de pièces où la concentration particulaire
est maitrisée afin de minimiser l'introduction, la génération et la rétention de particules à
l'intérieur. Les paramètres tels que la température, l'humidité et la pression relative sont
également maintenus à un niveau précis.
Cette interface devait être développé avec le jeune framework Ruby on Rails dont la
première version fût publiée en juillet 2004.

        Nous voulions réaliser un stage qui se démarque des autres et ne pas travailler avec
un langage et des outils que nous connaissions déjà.
Le choix du stage s'inscrit dans notre projet professionnel qui est de suivre l'actualité en
matière de nouvelles technologies, plus communément appelé veille technologique.
Il s'agit là d'anticiper les évolutions et innovations dans le domaine du web.

        Ce rapport s'organise de manière chronologique. Nous présenterons tout d'abord
succinctement l'entreprise, ainsi que le sujet du stage. Nous parlerons ensuite de la
recherche des outils nécessaires à notre projet. Nous aborderons les problèmes que nous
avons rencontrés, mais surtout les solutions que nous avons proposés. Nous enchainerons
sur le travail réalisé avec les fonctionnalités que nous avons développé. Enfin nous finirons
par la dernière étape qu'est le déploiement de la nouvelle application sur un serveur de
production.
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails
1. Présentation de l'entreprise

1.1. Entreprise
          Esolys est depuis Octobre 2007 une jeune entreprise. Sa mission est de devenir un
   acteur majeur dans la proposition de solutions basées sur Ruby on Rails dans la
   région lilloise.
   Son premier projet de développement Ruby on Rails est l'interface d'administration web
   qui gère les utilisateurs, les groupes et les différents processus de réalisations au laboratoire
   de l'IEMN.
   Son prochain projet est de développer un site communautaire pour la recherche
   d'évènements sur la région lilloise et ses alentours.

1.2. Méthodes de travail
           M. Jean-Sébastien Galloo nous avait laissé carte blanche quant à nos méthodes de
   travail et des solutions que nous proposions.
   Le framework Ruby on Rails que nous détaillerons dans la prochaine partie impose un
   développement agile.
   Cela implique notamment un développement incrémentiel. Chaque semaine nous
   fournissions un compte rendu des avancés à notre tuteur. Il nous indiquait en retour les
   corrections et améliorations à réaliser, ainsi que les nouvelles fonctionnalités à développer
   pour la semaine suivante.

         Nous avons pu mettre en pratique quelques idées de l'eXtreme Programming, du
   développement incrémentiel, mais aussi du Pair Programming.

    1.2.1. Le développement incrémentiel
          Le principe fondamental est de ne pas tout spécifier avant le codage. Il faut
   produire juste assez de spécifications pour implanter quelques fonctionnalités. Il faut
   ensuite les essayer, demander l'avis aux utilisateurs puis enchainer sur un autre cycle
   minimal de conception et de développement.

    1.2.2. Le Pair Programming
           La programmation se réalise en binôme. Les deux développeurs travaillent
   ensemble sur la même partie de code et sur un même poste de travail.
   Chaque développeur prend à tour de rôle le clavier. L'autre personne regarde
   attentivement le travail du binôme et peut intervenir dès qu'il décèle une erreur de
   conception.
   Les avantages d'une telle méthode de travail sont multiples. En voici les principaux :
        • Brainstorming : plus d'idées avec deux cerveaux.
        • Une meilleure connaissance du sujet : chaque partenaire apporte ses propres
           connaissances. Cela permet également une homogénéité des connaissances.
        • Un meilleur code : les erreurs d'architecture de l'application tendent à être moins
           fréquent.
        • Une productivité accrue : les statistiques montrent que les développeurs sont deux
           fois plus productifs pour une tâche donnée.

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                       6
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails
1.2.3. L'eXtreme programming

        L'eXtreme Programming (XP) est une méthode agile de gestion de projet
informatique adaptée aux équipes réduites avec des besoins changeants. Elle pousse à
l'extrême des principes simples.
En voici les 3 valeurs fondamentales à retenir :
     • Tests unitaires : À chaque modification du code, les tests sont relancés. Si une
        fonctionnalité n'est plus correct, elle est immédiatement détectée et permet ainsi
        d'être corrigée rapidement.
     • Refactoring (ou remaniement du code) : amélioration régulière de la qualité du
        code. Permet pour la suite du projet d'avancer dans de meilleures conditions et
        d'être plus rapide.
     • Programmation en binôme : application de la méthode du Pair Programming.

1.2.4. Subversion

        Il était impératif lorsque nous travaillions chacun sur notre poste, d'utiliser un
logiciel de gestion de version pour pouvoir s'y retrouver lors de nos modifications
respectives. Pour cela, nous avons décidé d'utiliser un standard : Subversion.
Subversion (en abrégé svn) est un logiciel libre publié sous licence Apache/BSD. Il a été
conçu pour remplacer CVS. Ses auteurs s'appuient volontairement sur les mêmes concepts
(notamment sur le principe du dépôt centralisé et unique) et considèrent que le modèle de
CVS est le bon, et que seule son implémentation est en cause.

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                7
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails
2. Présentation du sujet

2.1. Le sujet
            Le sujet du stage était le développement d'une interface d'administration
   ergonomique pour une application web de gestion de la salle blanche de l'IEMN.
   Cette application permettrait la gestion en temps réel de l'ensemble des étapes de
   réalisation de dispositifs électroniques avancés développés dans ce laboratoire (150
   utilisateurs minimum). Ces dispositifs sont confectionnés dans la salle blanche sous
   atmosphère contrôlée.

           Cette application doit être facilement accessible à toute personne du laboratoire
   quel que soit son niveau en informatique. Dans ce but, il était nécessaire de réaliser une
   interface d'administration ergonomique, intuitive et très simple d'utilisation basée sur
   les technologies web dites « 2.0 » (méthodologie Ajax en particulier et librairie javascript
   script.aculo.us : drag'n drop, auto-complétion...).

           Ce stage avait pour but de développer une partie de cette application en Ruby on
   Rails : la partie administration des personnes et des équipes des différents laboratoire de
   l'IEMN.

2.2. Choix de la technologie employée
          Ruby on Rails a été choisi pour les qualités que possèdent ses deux composantes
   que sont Ruby et Rails.
   Nous préciserons dans les sections suivantes les atouts de cette technologie.

    2.2.1. Ruby
   Ruby est un langage de programmation interprété orienté objet.

   La philosophie de Ruby est la suivante :
       • Toute donnée est un objet, y compris les types.
       • Toute fonction est une méthode.
       • Toute variable est une référence à un objet.

    2.2.2. Rails
         Ruby on Rails, également appelé RoR ou Rails est un framework web libre écrit
   en Ruby. Il suit le motif de conception Modèle-Vue-Contrôleur.

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                  8
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails
Rails est basé sur deux principes fondamentaux :
    • Ne pas se répéter (ou DRY : Don't Repeat Yourself) : les éléments de l'application
        ne doivent être qu'à un seul endroit. L'architecture MVC et la méta-programmation
        en Ruby rendent cela possible.
    • Convention plutôt que Configuration : il est inutile de préciser des détails
        lorsqu'ils respectent des conventions établies. Rails exploite cela en proposant des
        comportements par défaut pour la plupart de ses fonctionnalités.

       Rails intègre parfaitement et facilement Ajax :
Ajax permet de réaliser des pages dynamiques avec Javascript et XML pour envoyer des
requêtes au serveur sans recharger la page dans le navigateur. Rails supporte Ajax et offre
plusieurs méthodes pour en simplifier l'utilisation.

       La puissance du langage Ruby n'impose pas certaines limitations qui apparaissent
dans d'autres langages comme PHP.
Rails proposent de nombreuses méthodes pour simplifier l'écriture du code comme les
helpers.

      La communauté est très active pour développer de nouveaux plugins ou helpers.
Le développement d'une application RoR se veut donc aisé et très rapide.
Ruby on Rails s'imposait donc pour le développement de cette application.

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                  9
Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails
3. Recherche des outils

3.1. Internationalisation
          Le laboratoire de l'IEMN accueille de nombreux chercheurs étrangers. Il était
   donc important que le site web soit au moins traduit en anglais.

    3.1.1. Solutions existantes
           Par défaut, Rails n'incorpore pas de mécanisme de gestion de
   l'internationalisation du programme. Après une recherche sur la toile, nous avons
   constaté qu'il existait de nombreuses solutions, chacune avec ses avantages et ses
   inconvénients.

           Notre     premier     choix     s'était    porté    sur      plugin     Globalite
   (http://www.railsontherun.com/globalite). Celui-ci nous semblait intéressant sur plusieurs
   points :
        • Gestion du changement de la langue.
        • Gestion des formats de date.
        • Gestion de la monnaie.

          Des inconvénients majeurs sont cependant présents. Dans le fichier de traduction,
   les phrases à traduire sont disposées les unes à la suite des autres, ce qui engendre ces
   problèmes :
        • Rend le fichier illisible pour un programme dont le nombre de phrases à traduire
          est important.
        • Les performances de lecture sont de plus en plus faibles à mesure que le fichier
          devient de plus en plus conséquent.

    3.1.2. Solution retenue
            Nous avons finalement décidé d'utiliser un standard : gettext.
   Gettext est la bibliothèque GNU d'internationalisation (i18n). Elle est couramment
   utilisée pour écrire des programmes multilingues.
   Il suffit de renseigner dans un fichier po la traduction de la phrase à traduire. Ce fichier
   peut-être ouvert par un éditeur de texte classique ou spécialisé (comme PoEdit). Le
   traducteur peut donc aisément réaliser sa tâche sans avoir de connaissances en
   informatique.
   Ce fichier po sera ensuite compilé en un fichier binaire mo. Les performances de lecture
   seront donc optimum.

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                 10
3.2. Génération automatique de formulaire

   3.2.1. Introduction
          Nous voulions ajouter un peu de généricité à notre application. Nous avions donc
   recherché un moyen de générer automatiquement un CRUD:
       • Create
       • Read
       • Update
       • Delete

   Dans notre application, nous avons 2 modèles :
      • Utilisateur
      • Groupe

          Nous voulions implanter un système qui dès que l'on désirerait ajouter un champ
   supplémentaire, pour pouvoir par exemple modifier son âge, puisse se réaliser sans
   modifier le fichier de vue d'extension rhtml.

   3.2.2. Active Scaffold
           Après quelques recherches, nous avions trouvé rapidement un plugin très utilisé par
   la communauté Rails : Active Scaffold.
   Ce plugin se base sur un modèle comme le modèle utilisateur dans notre application et
   génère des vues complètes. Quelques options permettent de préciser si tel ou tel champ est
   visible et/ou éditable.
   Nous avions testé au début ce plugin avec un modèle utilisateur stocké dans une base de
   données MySql. De cette façon, la communication se réalise grâce à ActiveRecord.
   Nous avions ensuite testé avec notre serveur LDAP. Mais ici, la communication se réalise
   grâce à ActiveLDAP. Il fallait redéfinir le mécanisme interne de communication entre ces
   deux fonctions. Malheureusement, nous n'avions réussi car redéfinir le mécanisme
   d'affichage des informations contenues dans un serveur LDAP. La mécanisme de
   modification des données demandait des changements beaucoup trop interne de
   ActiveLDAP.
   La solution a donc été abandonnée.

   Conclusion :

           Au final, nos vues sont générées par nos soins.
   Au fil et à mesure que nous développions, nous nous sommes aperçus que nous devions
   apporter de nombreuses modifications aux vues pour satisfaire nos exigences.
   Il aurait était donc nécessaire d'abandonner à un moment ou à autre Active Scaffold.

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                11
3.3. Annuaire OpenLDAP

   3.3.1. Introduction
          Le stockage des utilisateurs et des groupes aurait pû être naturellement réalisé dans
   une base de donnée MySql. Rails simplifie cette implantation grâce à son module
   ActiveRecord.
   Une base de données est constituée de données tabulaires. Il aurait été intéressant de
   pouvoir disposer ces données de manière hiérarchisées.
   De plus, ces données ne seront pas sujettes à être modifiées de manière régulière. Il était
   donc intéressant de trouver une solution qui soit très performante en lecture et qui
   pouvait l'être un peu moins en écriture.

          Nous connaissions de nom le serveur LDAP (Lightweight Directory Access
   Protocol) qui est un protocole qui permet l'interrogation et la modification des services
   d'annuaire. Ce protocole repose sur TCP/IP. Un annuaire LDAP respecte généralement le
   modèle X.500 édicté par l'UIT-T : c'est une structure arborescente dont chacun des nœuds
   est constitué d'attributs associés à leurs valeurs.

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                 12
3.3.2. Implantation
       Avec l'accord de M. Jean-Sébastien Galloo, nous avions donc décidé d'étudier cette
solution.
Nous avons étudié la version open source de LDAP : OpenLDAP.
L'étude du fonctionnement nous a pris pas mal de temps. En effet, la compréhension du
serveur est assez aisée au premier niveau mais sa configuration est néanmoins particulière.

        Comme mentionné dans la section précédente, nous avions utilisé Active Scaffold
pour générer automatiquement nos vues.
Avec une base de données MySQL, aucun problème ne se posait. Avec un serveur LDAP,
rien ne marchait au début.
En effet, Rails gère l'échange de données avec MySQL grâce à son module ActiveRecord.
Or, ce module ne sait pas gérer la communication avec un serveur LDAP.

        Nos recherches nous avaient amené au plugin ActiveLDAP. Comme son nom
l'évoque, ce dernier permet de communiquer avec un serveur LDAP de la même manière
qu'ActiveRecord communique avec une base de donnée relationnel.
Grâce à ce plugin, nous arrivions à afficher les informations de notre annuaire par
ActiveScaffold. L'édition en revanche ne marchait pas.
Nous nous étions plongé dans le code d'Active Scaffold afin de créer un adaptateur pour
ActiveLDAP. Nous avions écrit certaines fonctions pour adapter LDAP à la logique
relationnel d'une base de données, mais il nous était apparu qu'en réalité il était nécessaire
de modifier bien plus de comportements pour pouvoir le faire fonctionner. Certains
changements demandaient une investigation poussée au cœur de Rails. Pour ces raisons,
nous avons donc abandonné ActiveScaffold.

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                   13
3.4. Fenêtres Ajax

    3.4.1. Solution prévue
         M. Jean-Sébastien avait déjà utilisé pour ses précédentes créations de site web la
   Prototype Window Class.

           Elle permet d'ajouter des fenêtres dans une page HTML. Elle est basée sur
   Prototype qui est un Framework JavaScript dont le but est de permettre au développeur
   de créer des applications web dynamiques.
   Cette librairie est rapidement devenu un choix standard pour implanter d'une manière
   idéale la méthodologie AJAX.
   Nous avions donc intégrer cette composante dans notre application Rails. Cependant, des
   difficultés ont été rencontrées quant à son intégration.
   En effet, la philosophie de Rails est de cacher de manière élégante tout le code Javascript
   produit par l'application. Or pour utiliser cette librairie, il est impératif d'intégrer soi-même
   son propre code JavaScript. Nous avions persisté dans cette voie en fournissant à Rails du
   code JavaScript. Nous avions donc bien réussi à créer des fenêtres. Un problème
   subsistait : les fenêtres générées envoyaient des codes de retour qu'il nous était
   impossible de récupérés. Il nous était donc impossible d'interagir convenablement avec
   ces fenêtres.

   En résumé, voici pourquoi nous n'avons pas intégré cette solution :
       • Intégration de code JavaScript contraire à la philosophie Rails.
       • Mauvaise intégration dans un environnement Rails.
       • Lenteur d'exécution des fenêtres.

   En conclusion, cette solution convient parfaitement pour une application PHP mais se
   trouve bien trop lourde de changements pour Rails.
   Nous devions donc rechercher une solution alternative.

    3.4.2. Solution finalement retenue

           Nous avons retenu la solution ThickBox.
   C'est un composant écrit en Javascript qui permet d'intégrer une fenêtre dans une page.
   ThickBox se base sur la librairie jQuery, toolkit Ajax léger et rapide. Ses fonctions
   permettent de montrer une image simple, plusieurs images, du contenu en file, le contenu
   d'une iFrame ou bien du contenu généré par Ajax.

   En résumé, nous avons opté pour cette solution pour les point suivants :
       • Son intégration avec la philosophie Rails
       • Sa légèreté et ses performances face à ses concurrents.

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                      14
4. Travail réalisé
          Dans cette partie, nous allons dans un premier temps décrire les fonctionnalités
   que nous avons développées. Dans un second temps, nous verrons les perspectives
   d'évolution de l'application.

4.1. Fonctionnalités de l'application
          Nous utilisons Thickbox pour le login.
   Quand une action nécessite des droits, la ThickBox apparait à l'écran. La page s'assombrit
   et devient inaccessible tant que l'utilisateur n'aura pas cliqué sur le bouton Connexion ou
   Annuler.

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                15
Après s'être connecté, la page affiche les utilisateurs et les groupes actuels.

        Si un utilisateur ou un groupe n'a pas envoyé de photo, une image par défaut
s'affiche.
La création d'un utilisateur est entièrement vérifiée au fur et à mesure grâce à des requêtes
Ajax.

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                  16
Si l'utilisateur tente quand même de créer un utilisateur invalide, des messages
d'erreurs apparaissent et expliquent pourquoi. Chaque champ qui pose problème est
entouré d'un liseré rouge.

       Tout le site web a été prévu pour fonctionner si l'utilisateur a désactivé JavaScript.
Le site web affiche dans ce cas un formulaire plus traditionnel, donc sans fonctions
JavaScript et requête Ajax.

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                  17
L'upload de la photo est calqué sur le fonctionnement de celui de Gmail. Un popup
apparait et demande la location du fichier. Ce popup affiche ensuite la photo et demande à
l'utilisateur s'il désire valider son choix. Grâce à une requête Ajax et un peu de JavaScript,
la photo de l'homme inconnue est mise à jour sans rechargement complète de la page.

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                   18
La recherche d'un utilisateur met automatiquement la page à jour sans la
recharger complètement grâce à Ajax.

Avec le champ « Rechercher » vide :

Avec le champ « Rechercher » qui contient la lettre 'j' :

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails   19
Détails d'un utilisateur grâce à ThickBox :

        La création d'un groupe repose sur les mêmes méthodes que celle d'un utilisateur.
Si le responsable a déjà été crée, on peut le sélectionner.

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                20
Détails d'un groupe. Tous les utilisateurs qui appartiennent à ce groupe sont aussi
listés.
Un clic sur le nom du responsable affiche son profil.

       Si l'utilisateur utilise un navigateur avec une langue étrangère, le site le détecte et
change automatiquement la langue en correspondance :

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                   21
4.2. Perspective d'évolutions
           Il nous a été demandé la possibilité d'ajouter une personne en temps
   qu'administrateur du site. Il s'agit en fait de promouvoir une personne, par exemple le
   responsable d'une équipe, en tant qu'administrateur du site. C'est-à-dire lui donner la
   possibilité de modifier toutes les informations liées aux personnes de l'équipe.
   L'ajout du nom de cette personne en dur dans le code est un moyen simple de réaliser cela.
   Celle solution manque cruellement de flexibilité.
   En effet, il devrait être possible à un non programmeur de promouvoir un utilisateur
   facilement à travers l'interface.
   Une solution élégante à ce problème : assigner à chaque personne un ou plusieurs rôles.

            Le stage arrivait à sa fin, nous n'avons pas pu traiter cette demande. Néanmoins,
   nous donnons ci-après quelques pistes de recherches.
   Le site suivant propose quelques solutions sous forme de plugins pour Rails :
   http://technoweenie.stikipad.com/plugins/show/Acts+as+Authenticated

   Le plugin Authorization Plugin (http://www.writertopia.com/developers/authorization)
   nous paraissait être intéressant sur plusieurs points :
       • Simplicité d'utilisation dans la philosophie Rails.
       • Puissance d'utilisation (gère les expressions régulières pour définir les rôles).

           Le travail réalisé constitue la base de l'application. Notre objectif était de gérer les
   personnes des différents laboratoires de l'IEMN.
   Le programme s'inscrit dans un plus grand projet.
   Le problème actuel dans la procédure de réalisation de projet à l'IEMN, est que la personne
   travaillant dans la salle blanche doit transférer manuellement les données d'un
   ordinateur à un autre pour chaque étape de la conception. Cette organisation fait
   perdre du temps, à tel point que certaines personnes ne prennent même plus la peine de
   renseigner leur passage dans la salle blanche.
   Le logiciel développé devrait pallier ces problèmes.
   Cette interface web permettrait d'assister la personne dans les différentes étapes de
   création d'un composant électronique au sein de la salle blanche de l'IEMN.

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                     22
5. Déploiement
   Le déploiement se décompose en deux parties :
      1. Installation de Ruby, Rails et des divers plugins utilisés par notre application.
      2. Déploiement de l'application

5.1. Installation de Ruby + Rails + plugins
           Lorsqu'il s'agit d'installer un programme sous Linux, plusieurs possibilités s'offre à
   nous. Soit installer le programme à partir des sources, soit avec le gestionnaire de paquet
   de la distribution. Cette dernière solution est d'ailleurs recommandé dans la plupart des
   cas.
   Comme nous travaillons sous la distribution Ubuntu, l'installation la plus facile et la plus
   rapide se résume à la simple commande suivante :
           sudo apt­get install ruby rails

         Avec cette commande, nous pensions pouvoir commencer tout de suite à
   programmer, or ce ne fût pas le cas.

            Par défaut, Rails utilise le serveur web WebRick, entièrement écrit en Ruby et
   libre. Il est inclus dans Ruby depuis la version 1.8 du langage.
   Ce serveur fonctionne très bien dans le cadre d'un environnement de développement mais
   s'avère trop peu performant dans le cadre d'un environnement de production. Nous
   avions donc décidé d'utiliser dès le début la solution préconisée dans le livre Ruby on Rails
   aux éditions Eyrolles : installer le serveur Mongrel.
   Le serveur HTTP Mongrel, écrit en Ruby et en C a été conçu pour être léger, rapide et
   sécurisé.
   Rails intègre son propre gestionnaire de paquets qui facilite la gestion des installations et
   mises à jour des plugins : les gems.
   L'installation du serveur Mongrel donne donc :
            sudo gem install ­­include­dependencies mongrel

           Malheureusement, nous nous sommes heurtés au problème d'incompatibilité de
   versions. En effet, Mongrel demande la dernière version de Ruby. L'installation de Ruby
   par le gestionnaire de paquets ne nous fournit pas sa dernière version en date.

          Nous avons donc décidé d'abandonner l'installation de Ruby par le gestionnaire de
   paquets. Nous avons créé un script bash qui récupère sur Internet les dernières version de
   Ruby, Rails et des autres plugins utilisés par notre site web. Le script s'occupe ensuite de
   compiler et d'installer tout le nécessaire de manière automatique.
   Vous pourrez retrouver ce script en annexe 1.

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                   23
5.2. Déploiement de l'application
          La machine contient maintenant tout ce qu'il faut pour pouvoir exécuter une
   application Ruby on Rails.
   Il nous manque le plus important : l'application elle-même. La dernière étape est donc de
   transférer l'application sur le serveur et de configurer ce dernier pour pouvoir répondre
   aux requêtes.

           Pour déployer notre application, nous avions étudié la solution préconisée dans le
   livre Ruby on Rails aux éditions Eyrolles à savoir l'utilisation du plugin Capistrano.

           Dans la section suivante, nous vous présentons pourquoi cette solution n'a pas été
   retenu. Nous concluons sur la solution finalement prise.

    5.2.1. Capistrano + Mongrel + Apache
           Capistrano est un utilitaire de déploiement d'applications Web, recommandé pour
   les applications de Ruby on Rails.
   Capistrano devait donc déployer les fichiers de notre site web et configurer
   l'environnement du serveur.

          Notre serveur utilise Mongrel comme serveur interne et Apache comme serveur
   web frontal.

           Capistrano devait donc se charger aussi de mettre à jour ces processus.
   La tentative de déploiement avec cet utilitaire nous avait déçu. En effet, Capistrano réalise
   de nombreuses tâches que nous ne souhaitions pas ou des tâches avec des paramètres
   incorrects non modifiables.
   Nous avons donc décidé de créer une documentation qui précise un déploiement
   parfaitement contrôlé sur un serveur Linux Ubuntu.

    5.2.2. Documentation + Mongrel + Apache
          La documentation que nous avons écrit directement en anglais s'est voulue assez
   exhaustive.

   Nous y détaillons les points suivants :
      • Comment déployer le serveur OpenLDAP et tester sa bonne mise en
         fonctionnement.
      • Installer Rails et les gems utilisées par le site web.
      • Déployer les fichiers du site web sur le serveur.
      • Initialiser un cluster Mongrel.
      • Configurer et démarrer Apache.

   Ainsi de cette manière nous maitrisons le déploiement de notre application sans surprise.
   Vous pourrez retrouver cette documentation en annexe 2.

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                  24
Conclusion
       Ce stage labo d'un mois s'est déroulé dans le cadre de notre formation en Master 1
parcours GMI. Nous avons réalisé ce stage à Esolys, hébergé au pré-incubateur de
l'USTL Cré'Innov.
Le but du stage était de nous initier au monde de la recherche. En effet, après notre
Master 1 nous aurons le choix entre continuer en Master 2 Pro en vue de travailler en
entreprise, ou en Master 2 Recherche pour devenir chercheur.

        Nous avons travaillé pour M. Jean-Sébastien Galloo qui est aujourd'hui chef
d'entreprise dans le secteur de l'informatique. De part son ancien statut de chercheur au
laboratoire de l'IEMN, il connaissait bien les besoins que possédait ce laboratoire.
Actuellement, la gestion des utilisateurs, des groupes et des différents étapes des processus
de fabrication de la salle blanche de l'IEMN sont gérées manuellement. Des besoins de
gestion et d'organisation se ressentaient.
Ce stage devait donc mettre en place la structure et les premiers développements d'une
interface web ergonomique de type « Web 2.0 ».
En effet, ces chercheurs ont une formation en électronique et ne maitrisent pas forcément
bien l'outil informatique. Notre interface d'administration des utilisateurs et des groupes se
devait donc d'être la plus intuitive et ergonomique possible. C'est ce vers quoi nous
avons tendu à réaliser tout le long de ce stage.

        La technologie principale utilisée est Ruby on Rails. La jeunesse du framework
Rails nous a amené tout le long du stage à rechercher sur Internet des solutions qui
n'étaient pas intégrées dans le framework par défaut, ou à les développer nous-mêmes.
Nous pensons surtout à l'intégration d'un serveur LDAP dans notre projet.

        Nous nous sommes aussi occupés du problème du déploiement. Il a été simplifié
par la création d'une documentation.

        Le projet connaitra encore un long développement pour gérer les différents
processus de la salle blanche. Ce développement sera certainement réalisé par d'autres
stagiaires.

Vous pouvez maintenant apprécier nos conclusions personnelles.

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                   25
Conclusion Vincent
        Ce stage d'un mois s'achève sur un sentiment de travail bien fait. En effet nous
avons fini les objectifs demandés au départ et avons même basé l'application sur un
annuaire LDAP que j'avais proposé d'incorporer dès le début.
J'avais envie d'étudier un peu comment utiliser un annuaire LDAP car c'est un outil très
intéressant pour avoir un serveur d'authentification commun à plusieurs applications. Il
est par exemple possible de posséder un seul login et mot de passe pour se connecter à la
fois à un dépôt subversion, un forum, un blog et un wiki.

        J'ai choisi ce stage sur Ruby on Rails (RoR) pour expérimenter un nouveau
framework en vogue dans la création d'interfaces web.
Ce stage s'inscrit logiquement dans mon projet professionnel qui est de faire du
développement web et devenir expert consultant dans une ou plusieurs technologies. J'ai
d'ailleurs travaillé cet été sur le framework Zope/Plone pour la création de portails
collaboratifs dans l'entreprise Ecréall où j'avais fait mon premier stage en janvier.

        Ayant une expérience dans ces deux frameworks, je peux voir les forces et
faiblesses de chacun d'eux.
        RoR permet d'utiliser avec une facilité déconcertante les technologies Ajax :
modification d'une zone spécifique d'une page sans recharger complètement celle-ci, ou
bien des effets visuels comme l'indication de changement d'un champ de formulaire. Je
pense que RoR est très bien pour un besoin spécifique, du sur mesure. Il manque
cependant de nombreuses choses dans ce framework et le seul moyen d'y remédier et
d'installer des plugins additionnels.
        Quant à Zope/Plone, c'est un très bon CMS avec de nombreuses fonctionnalités
incluses par défaut, ce qui le rend incontournable pour un portail collaboratif complexe.
        Pour le niveau de difficulté de compréhension et d'apprentissage, les deux
frameworks ne jouent pas dans la même catégorie. Pour Zope/Plone, je dirai qu'il faut un
apprentissage d'au moins deux mois. Au contraire RoR s'apprend très vite. En deux
semaines avec un bon livre, il est aisé de réaliser rapidement une application web.

        J'ai pu faire profiter Jérôme de mon expérience en Pair Programming que j'ai
acquis lors de mon travail cet été. J'aime beaucoup cette méthode de développement car
elle permet aux deux développeurs de partager leurs connaissances, ainsi que de trouver
des idées plus facilement.

       J'adore apprendre de nouvelles choses. Le fait que le développement web est un
domaine sans cesse en évolution me plait donc beaucoup. Ce stage me conforte dans l'idée
de continuer sur cette voie.

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails              26
Conclusion Jérôme

        J'ai choisi ce stage d'une part pour avoir une première expérience en technologie
web, et d'autre part pour pratiquer un framework prometteur basé sur Ajax.

        En effet, après avoir eu une première expérience dans le monde de la grande
distribution chez Cylande avec l'utilisation de technologies éprouvées, ce stage a été
l'occasion de découvrir le milieu de la recherche et ses technologies innovantes.

        Comme je ne connaissais que les bases de html, css, Javascript, php et MySQL au
travers de quelques cours et réalisations personnelles, ce stage m'a demandé un
investissement personnel important à savoir la lecture et l'assimilation du livre de
référence de Dave Thomas de 797 pages ...

        Programmer avec un framework aussi jeune que Rails est une expérience vraiment
enrichissante. En effet, il ne suffit pas de se rendre sur des sites traditionnels comme
developpez.com avec ses FAQ très fournies pour trouver les réponses à ses problèmes. Il
fallait par exemple se rendre sur de multiples sites de passionnés qui réalisent de la veille
technologique. Toutes les réponses étaient loin de se trouver sur Internet. Des réflexions
se sont posées tout au long du stage. Je pense notamment à l'intégration de la gestion de
l'internationalisation.

        Ce stage m'a permis de travailler en équipe et d'appliquer la méthode de travail du
Pair Programming. Nous étions particulièrement complémentaires. Vincent avec son
expérience dans le développement web, et pour ma part la connaissance de Ruby on
Rails qui nous assuré un démarrage rapide. Ce qui a été particulièrement important vu le
peu de documentations existantes et la courte durée du stage.

         Ruby on Rails (et plus globalement tout ce qui se rapporte avec les méthodes
Ajax) m'a montré les nouvelles capacités que proposeront les sites webs ces prochaines
années. Ce qui constituera un atout supplémentaire pour ma future carrière
professionnelle.

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                  27
Bibliographie

Ruby on Rails
       •   Dave Thomas, David Heinemeier Hansson. Ruby on Rails 2e édition, Eyrolles,
           2007, 780 p.
       •   Site officiel de Ruby on Rails : http://www.rubyonrails.org/
       •   Tutoriels sur Ruby : http://ruby.developpez.com/

Subversion
       •   Site officiel de subversion : http://subversion.tigris.org/
       •   Tutoriel sur l'utilisation de subversion :
           http://artis.imag.fr/Members/Xavier.Decoret/resources/svn/index.html

Plugins
       •   Page sur le plugin ActiveLDAP :
           http://wiki.rubyonrails.org/rails/pages/ActiveLDAP
       •   Using Gettext To Translate Your Rails Application :
           http://manuals.rubyonrails.com/read/chapter/105
       •   Plugin pour avoir des noms de champ humanisé dans les erreurs de formulaire
           : http://agilewebdevelopment.com/plugins/human_attribute_override
       •   Plugin pour générer un mot de passe aléatoire prononçable :
           http://agilewebdevelopment.com/plugins/phonemic_passwords
       •   Boite Ajax ThickBox de la librairie jQuery : http://jquery.com/demo/thickbox/

OpenLDAP
       •   Tutoriel d'installation d'openldap sur Ubuntu : http://doc.ubuntu-fr.org/slapd
       •   Getting Started with LDAP :
           http://www.linuxdevcenter.com/pub/a/linux/2001/11/08/ldap.html
       •   Explications sur LDAP :
           http://www-sop.inria.fr/semir/personnel/Laurent.Mirtain/ldap-livre.html
       •   RFC utile pour connaitre les attributs que l'on peut utiliser dans les entrées
           LDAP : http://www.ietf.org/rfc/rfc2256.txt
       •   OpenLDAP Software 2.3 Administrator's Guide:
           http://www.openldap.org/doc/admin23/

Gestion des rôles
       •   simple authentication generator plugin for Ruby on Rails :
           http://technoweenie.stikipad.com/plugins/show/Acts+as+Authenticated
       •   a flexible way to add authorization to Rails :
           http://www.writertopia.com/developers/authorization

Selenium IDE
       •   Extension Firefox pour réaliser des tests fonctionnels :
           http://www.openqa.org/selenium-ide/

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                 28
Annexes

Annexe 1 : Script d'installation

    # http://blog.mondragon.cc/articles/2007/02/03/compiling-ruby-1-8-5-w-openssl-on-
    debian-etch-testing-and-freebsd-in-home
    # http://www.ruby-forum.com/topic/90083
    # http://blog-perso.onzeweb.info/2007/03/28/multiples-ruby/

    # Install dependencies with apt-get
    apt-get update
    apt-get install build-essential libreadline5-dev zlib1g-dev libssl-dev libldap2-dev
    libmagick++9-dev

    RUBY_VERSION=1.8.6
    RUBYGEMS_VERSION=0.9.4
    RUBYLDAP_VERSION=0.9.7
    RMAGICK_VERSION=1.15.10

    ## You don't have to edit below normally ##
    PKG=$PWD/packages
    if [ ! -e $PKG ]; then mkdir -p $PKG; fi

    # Download the last version of stable ruby on http://www.ruby-lang.org/
    RUBY_SITE=ftp://ftp.ruby-lang.org/pub/ruby/1.8
    RUBY_TB=ruby-$RUBY_VERSION.tar.bz2
    RUBY_DIR=ruby-$RUBY_VERSION

    # http://rubyforge.org/projects/rubygems/
    RUBYGEMS_SITE=http://rubyforge.org/frs/download.php/20989
    # don't add a final slash for this one
    RUBYGEMS_TB=rubygems-$RUBYGEMS_VERSION.tgz
    RUBYGEMS_DIR=rubygems-$RUBYGEMS_VERSION

    #
    RUBYLDAP_SITE=http://mesh.dl.sourceforge.net/sourceforge/ruby-ldap
    RUBYLDAP_TB=ruby-ldap-$RUBYLDAP_VERSION.tar.gz
    RUBYLDAP_DIR=ruby-ldap-$RUBYLDAP_VERSION

    RUBY_HOME=/usr/local/ruby-$RUBY_VERSION
    RB=$RUBY_HOME/bin/ruby

    if [ -e $RUBY_HOME ]; then
             rm -rf $RUBY_HOME
    fi
    if [ ! -e $PKG/$RUBY_TB ]; then
             wget -P $PKG $RUBY_SITE/$RUBY_TB
             if [ $? -ne 0 ]; then exit 1; fi
    fi
    cd /tmp/ &&\
    rm -rf $RUBY_DIR &&\
    tar xvf $PKG/$RUBY_TB &&\
    cd $RUBY_DIR &&\
    ./configure --prefix=$RUBY_HOME &&\

    Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails              29
make &&\
make install &&\
cd - &&\
rm -rf $RUBY_DIR
if [ $? -ne 0 ]; then exit 1; fi

# install rubygems
if [ $? -ne 0 ]; then exit 1; fi
if [ ! -e $PKG/$RUBYGEMS_TB ]; then
         wget -P $PKG $RUBYGEMS_SITE/$RUBYGEMS_TB
         if [ $? -ne 0 ]; then exit 1; fi
fi
cd /tmp/ &&\
rm -rf $RUBYGEMS_DIR &&\
tar xvf $PKG/$RUBYGEMS_TB &&\
cd $RUBYGEMS_DIR &&\
$RB setup.rb
cd - &&\
rm -rf $RUBYGEMS_DIR
if [ $? -ne 0 ]; then exit 1; fi

# install ruby-ldap
if [ $? -ne 0 ]; then exit 1; fi
if [ ! -e $PKG/$RUBYLDAP_TB ]; then
         wget -P $PKG $RUBYLDAP_SITE/$RUBYLDAP_TB
         if [ $? -ne 0 ]; then exit 1; fi
fi
cd /tmp/ &&\
rm -rf $RUBYLDAP_DIR &&\

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails   30
Annexe 2 : Documentation pour le déploiement
   ==============================
   Deployment on an Ubuntu Server
   ==============================

   You will need the following packages:

           apt-get install ssh subversion slapd ldap-utils apache2

   OpenLDAP
   ========
   First, you have to set up an openldap server
   -----------------------------------------------------
   As root, edit /etc/ldap/slapd.conf and change all occurences of "dc=nodomain" by
   "dc=example,dc=com" or by your own domain. ("dc=example,dc=com" is used in \*.ldif)

   Then add rootdn and rootpw keys:

           rootdn            "cn=admin,dc=example,dc=com"
           rootpw            secret

   or if you don't want a plain/text password, crypt it with slappasswd an copy the resulting
   string, e.g :

           rootpw            {SSHA}v6s7gnyXfA50jwILOaRiODHqUsA54I9U

   Delete existing database and start the slapd daemon
   --------------------------------------------------------------
   as root:

           /etc/init.d/slapd stop

   if you executed slapd manually => "ps aux|grep slapd" and kill the pid
   delete existing database and start the slapd daemon::

           rm -rf /var/lib/ldap/*
           /etc/init.d/slapd start

   check it's running with "ps aux", if not, execute slapd manually.

   Create the base of the LDAP tree and fill it with some users and groups
   -------------------------------------------------------------------------------------
           ldapadd -x -W -D"cn=admin,dc=example,dc=com" -f base.ldif
           If you want to add 3 users and 2 groups to test the server:
           ldapadd -x -W -D"cn=admin,dc=example,dc=com" -f users_groups.ldif

   Verify the openldap server is set up correctly:
           ldapsearch -xLLL -w secret -D"cn=admin,dc=example,dc=com" -b

   Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                     31
"dc=example,dc=com" uid=johndoe
Should return:
       dc=example,dc=com" uid=john.doe
       dn: uid=john.doe,ou=users,dc=example,dc=com
       uid: john.doe
       objectClass: inetOrgPerson
       cn: John Doe
       givenName: John
       [...]

For more documentation on openldap
---------------------------------------------
- http://doc.ubuntu-fr.org/slapd
- http://www.linuxdevcenter.com/pub/a/linux/2001/11/08/ldap.html
- http://www-sop.inria.fr/semir/personnel/Laurent.Mirtain/ldap-livre.html
- http://www.ietf.org/rfc/rfc2256.txt
- http://www.openldap.org/doc/admin23/

Install rails and required gems
======================
execute the script:

        svn co http://crome.homelinux.com/devsvn/scripts
        cd scripts
        ./install_ruby.sh

Install your rails app on the server
========================
ssh to your server, I suggest you to create a specific user to launch your mongrels server:

        adduser rails

Optional, if you want to not type yout password every time you connect to the server,
create a RSA public/private keys on your local machine:

        ssh-keygen -t rsa

and transfer it to the server:

        ssh rails@server_ip "mkdir .ssh; chmod 0700 .ssh"
        scp .ssh/id_rsa.pub rails@server_ip:.ssh/authorized_keys

On the server, check out the latest version of your rails app:

        cd /home/rails
        svn co http://crome.homelinux.com/devsvn/adminusers/trunk adminusers
        mkdir adminusers/tmp/{cache,pids,sessions,sockets}

Now configure config/ldap.yml with the same config as /etc/ldap/slapd.conf

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                      32
This rails app depends on active_ldap (http://rubyforge.org/projects/ruby-activeldap
). To install it, install gettext's gem, build ruby-ldap and then build active_ldap.
This is done by the install_ruby.sh script above.

Generate mo files:

        rake makemo

Start the server:

        ruby script/server

And try to create, edit, destroy some users and groups.
If all is alright, shutdown the server with CTRL+C

Mongrel Cluster
============
Now we want to configure a mongrel cluster, here we are two mongrels, one on 8000 port,
and the other on 8001 listening to 127.0.0.1:
        mongrel_rails cluster::configure -e production -p 8000 -a 127.0.0.1 -N 2
-c /var/www/adminusers

This command generate the config/mongrel_cluster.yml file which is used by
mongrel_rails cluster::* commands

To start it, in your rails app directory (here /home/rails/adminusers):

        mongrel_rails cluster::start

Now you should have access to the two rails instances at http://127.0.0.1:8000/admin and
http://127.0.0.1:8001/admin

To stop it:

        mongrel_rails cluster::stop

To restart it:

        mongrel_rails cluster::restart

Apache
======
Then create a new VirtualHost /etc/apache2/sites-available/adminusers (see example in the
doc directory on subversion) and make a symlink in sites-enabled like this:

        cd /etc/apache2/sites-enabled/
        ln -s ../sites-available/adminusers 001-adminusers

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails               33
Enable proxy_balancer and proxy_http modules:

       a2enmod rewrite
       a2enmod proxy_balancer
       a2enmod proxy_http

and edit /etc/apache2/mods-available/proxy.conf to allow proxy for specific domain
domain or ip, for example:

          AddDefaultCharset off
          Order deny,allow
          #Deny from all
          Allow from 127.0.0.1, 192.168.68.4
          #Allow from .example.com
     
Finally, reload apache:

       /etc/init.d/apache2 reload

Now you should have access to a rails instance with http://127.0.0.1/admin

Selenium tests
===========
There exists some functional tests in the test/selenium directory.
You need to install the "Selenium IDE" extension for firefox.
The tests work only with the english site, so you need to select "en" for the default
language in the firefox preferences.
To execute the test suite:

       firefox -chrome "chrome://selenium-ide/content/selenium/TestRunner.html?
test=file:///home/pseudo/adminusers/test/selenium/TestSuite.html&auto=true&baseU
RL=http://localhost:3000/"

Localization
=========
To update the pot and all po files:

       rake updatepo

To update a translation, edit the corresponding po file.

If you want to create a new translation, for example russian:

       mkdir po/ru
       msginit -i po/adminusers.pot -o po/ru/adminusers.po

Réalisation d'une interface de gestion des utilisateurs en Ruby on Rails                34
Vous pouvez aussi lire