How to redirect to different AJP connector based on server name only (same context path)

When you have two domains pointing to the same IP address, how to server different page only based on the URL.

-  Setup 2 tomcat listening on AJP port 8019 and 8009

- declare two domains on you DNS page

Then modify the apache configuration as follow.



NameVirtualHost *:80
ProxyPreserveHost On

ProxyPass  /  ajp://localhost:8009/
ProxyPassReverse /  ajp://localhost:8009/
ServerName virtualserver1.mydomain.com


ServerName virtualserver2.mydomain.com
ProxyPass / ajp://localhost:8019/
ProxyPassReverse /  ajp://localhost:8019/

Remove dead code from your application

The problem:
Code coverage estimation is mostly based on Automated Unit Testing and software like JUnit. Doing like this is okay to increase youy coverage rate, but sometimes has a pernicious effect. Because it does not guarantee that the code you cover is really necessary to your application, and so you may have some portions of code covered but unrelevant for the actual application business.

Unecessary code detected with UCDetector:
In order to avoid this unecessary code, you have several alternatives. The first is to use the excellent eclipse plugin UCDetector (standing for Unecessary Code Detector) downloadable at http://www.ucdetector.org/. This detects in a friendly way the code that is not referenced elsewhere in the project.

This plugin must be applied to relevant package for application business. Indeed,  service packages and dao packages are good candidates. The result comes in the markers tabs of eclipse. You can then decide weither or not, those method shall be kept or not. 

Unecessary code detected with Tomcat and code coverage:
The below method can only apply to the low layer in a webapp, because you cannot check the code accessed throught JSP. For an in deep investigation of the actual code used, you may use cobertura and tomcat together.

Supposing you have a maven project. Here is the way to do it.
First, build your package :
- mvn package

The project is built in the target/myproject.war archive.

- mvn cobertura:instrument

This creates a folder named
- target\generated-classes\cobertura containing the instrumented classes.

This also creates a file named :

- target\cobertura.ser this files is a database storing the coverage information.

We have to build an instrumented war.

- Unzip the myproject.war file in the folder myproject
- Copy the cobertura.jar file in the myproject/WEB-INF/lib folder
- Replace the classes in folder myproject/WEB-INF/classes by the one produced in target\generated-classes\cobertura

Now it is time to prepare your tomcat:
Copy the cobertura.ser file in the folder where you will launch tomcat. If you are lauching tomcat through the windows explorer,  this folder is the /bin/ directory. If your are lucnhing it through a console, the folder is the current working directory.

Now you can run your tomcat.

Finally produce your report using the command

cobertura-report.bat --datafile ./cobertura.ser --destination ../report --format html ../sources/

Specials if you have your project distibuted in several modules^, you may first merge your cobertura information into a single file before launching tomcat :

cobertura-merge.bat --datafile target/cobertura_final.ser ../myproject-service/target/cobertura/cobertura.ser ../myproject-webapp/target/cobertura/cobertura.ser

AJP13 avec apache

Pour router votre serveur apache vers le serveur tomcat, il faut utiliser un proxy, apache délègue sa requête au serveur tomcat. Ce mode de fonctionnement permet surtout de faire du load balancing et, lorsqu'il s'agit de servir des fichiers, utiliser la code natif plus performant de apache.

Après avoir installé et déclarés le module proxy_ajp_module dans le fichiers httpd.conf :

LoadModule proxy_module modules/mod_proxy.so
LoadModule proxy_connect_module modules/mod_proxy_connect.so
LoadModule proxy_ftp_module modules/mod_proxy_ftp.so
LoadModule proxy_http_module modules/mod_proxy_http.so
LoadModule proxy_ajp_module modules/mod_proxy_ajp.so

Ajouter dans le fichier httpd.conf les lignes suivantes

Include conf/vhosts.d/*.conf
<Location /wiki >
 AuthType Basic
 AuthName "Restricted Files"
 AuthUserFile /etc/apachepasswd
 Require user wiki
 ProxyPass ajp://localhost:8009/JSPWiki
 ProxyPassReverse ajp://localhost:8009/JSPWiki
 allow from all
</Location>
<Location /gestion >
 ProxyPass ajp://localhost:8009/gestion
 ProxyPassReverse ajp://localhost:8009/
 allow from all
</Location>

Autrement, il est aussi possible de créer un fichier worker.properties 
# worker "worker1" will talk to Tomcat listening on machine www.x.com at port 8007 using 2 lb factor
worker.list=worker1
worker.worker1.host=myhost
worker.worker1.port=9009
worker.worker1.lbfactor=2

# Update this path to match your conf directory location (put workers.properties next to httpd.conf)
JkWorkersFile /etc/httpd/conf/worker.properties
# Where to put jk shared memory
# Update this path to match your local state directory or logs directory
JkShmFile     /var/log/httpd/mod_jk.shm
# Where to put jk logs
# Update this path to match your logs directory location (put mod_jk.log next to access_log)
JkLogFile     /var/log/httpd/mod_jk.log
# Set the jk log level [debug/error/info]
JkLogLevel    info
# Select the timestamp log format
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "
# Send everything for context /examples to worker named worker1 (ajp13)
JkMount  /ft-jobs/* worker1

Changer l'URL

Pour configurer de manière centralisée les applications, il est possible d'utiliser un apache frontal et de repartir les adresses vers des serveurs mandatataires, apache agit donc comme un proxy et il suffit d'ajouter la ligne suivante dans le fichier httpd.conf
Par exemple si la machine vm04 est le frontal et que le serveur hudson est sur la vm04, il suffit d'ajouter la ligne suivante au fichier httpd.conf

ProxyPass   /hudson/  http://vm04:8080/hudson/

On accedera à hudson par l'url http://vm01/hudson/

Faire du load balancing

Solution n°1

<Location /jonas>
ProxyPass   balancer://mycluster/
ProxyPassReverse  balancer://mycluster/
Allow From All
</Location>


<Proxy balancer://mycluster>
BalancerMember  ajp://localhost:9009/myapp
BalancerMember  ajp://localhost:8009/myapp
</Proxy>

Solution n°2

ProxyPass   http://localhost/myapp/
ProxyPassReverse /myapp/
Allow From All


JkWorkersFile /etc/httpd/conf/worker.properties
JkShmFile     /var/log/httpd/mod_jk.shm
access_log)
JkLogFile     /var/log/httpd/mod_jk.log
JkLogLevel    info
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "
JkMount  /myapp/* worker1

Debugging distant avec tomcat et eclipse

Dans setenv.sh rajouter la ligne :

export JAVA_OPTS="-Xmx1024M -Xdebug -Xrunjdwp:transport=dt_socket,address=8000,server=y"

Si vous souhaitez que le serveur ne démarre que s'il est connecté à éclipse.
Tapez :

export JAVA_OPTS="-Xmx1024M -Xdebug -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=y"

Ensuite sur eclipse dans le menu debug

Choisissez

- Java Remote Application

Dans project choisissez le projet que vous voulez mettre en relation avec la tomcat, le source doit être celui qui a permis de générer votre application distante, sans quoi vous aurez des résultat incohérent.

Placez les breakpoints où vous le souhaitez, le remote debugging vous permettra de voir les variable, de placer des breakpoint etc. exactement comme dans un debbuging local.

Utiliser la JConsole avec tomcat

JConsole est un utilitaire fourni avec le JDK. Il permet de voir l'état d'une machine virtuelle et il est particulièrement utile lorsqu'il s'agit d'effectuer le diagnostic de performance d'une application.

Pour une application Web, il faut observer le tomcat. Pour ce faire, on crée dans le répertoire bin un fichier setenv.sh en ajoutant la ligne suivante :

if [ "$1" = "start" ]; then
export JAVA_OPTS="-Dcom.sun.management.jmxremote \
 -Dcom.sun.management.jmxremote.port=50001 \ 
 -Dcom.sun.management.jmxremote.ssl=false \
 -Dcom.sun.management.jmxremote.authenticate=false"
fi

Ou bien sous windows dans setclasspath (de Tomcat 6.0)
set JAVA_OPTS="-Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.port=50001 -Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false"

Ensuite il faut lancer JConsole et se connecter sur la machine à observer sur le port 50000. Bien entendu, il est possible de sécuriser l'accès à ces informations.


-verbose:class permet d'afficher d'ou sont chargée les différentes classes.

Utilisation de cargo

Configuration du plugin en mode local et remote
Voici la ligne à insérer dans le pom.xml

<plugin>
<groupId>org.codehaus.cargo</groupId>
<artifactId>cargo-maven2-plugin</artifactId>
<configuration>
<configuration> (Indique ou sont déployés les war)
<type>existing</type> (Le type par defaut est standalone, c'est à dire que les repertoire de deploiement est créé s'il n'existe pas)
<home>/opt/tomcat/</home> (Nécessaire dans le cas d'un existing)
</configuration>
<container>
<containerId>tomcat5x</containerId>
<home>/opt/tomcat/</home> (Home indique ou trouver le container (le moteur))
</container>
</configuration>
</plugin>

Pour pouvoir déployer sous un chemin spécifique, indépendamment des version, il faut créer le fichier META-INF/context.xml et affecter le nom d'application que l'on souhaite.

<Context path="/gestion" />

Configurer ses datasources tomcat ou jonas et Spring

Récupérer la datasource dans le code

        Context initialContext = null;
      log.error("Initializing supervision servlet");
      try {
          initialContext = new InitialContext();
          DataSource dataSource = (DataSource) initialContext
                  .lookup("java:comp/env/jdbc/Journal");
          connection = dataSource.getConnection();
      } catch (Exception e) {
          log.error("Cannot get initial context for JNDI: ");
          e.printStackTrace();
          log.error(e);
      }

Une connexion est obtenue à partir du DataSource. Cette connexion est une implémentation particulière puisque son appel à la méthode close() ne la ferme pas réellement mais la rend à nouveau disponible au pool de connexion. Sans cette action permet la connexion ne se libère pas. Pour cette raison, il est très important que la méthode close soit appelée et même en cas d'exception. Sans cela, sans cela le pool de la database perd des connections et il peut résulter une insiponibilité de la database.

Le mieux est de faire close() de la session dans un bloc finally pour garantir son appel.

      try{
            connection=getConnection(); // Permet de récupérer une connexion à partir du DataSource
                 ...
            traitement
                 ...
            resultSet.close();
            connection.close();
            logger.debug(infoDossiers.size() + " dossiers retournés");
            return infoDossiers;
        } catch (SQLException e) {
            try {
                logger
                        .error(
                                "Erreur lors de la requête de récupération des infos du dossier pour l'identifiant : "
                                        + identifiant
                                        + " de type : "
                                        + typeIdentifiant
                                        + " pour l'année :"
                                        + annee, e);
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e1) {
                logger.error("Erreur lors de fermeture de la connection");
            }

Le fichier context.xml définit cette data source. Il peut être placé dans le répertoire META-INF/context.xml, dans ce cas, il est rechargé à chaque déploiement. La ressource peut aussi être définie au niveau du Host en créant un fichier context.xml.default dans le répertoire conf/Catalina/localhost de tomcat. Dans ce cas le déploiement ne reconfigure pas la datasource. Le fichier de context s'écrit :

<Context displayName="Calam-WS"  path="/calam-ws">
 <Resource name="jdbc/MyDataSource" auth="Container" type="javax.sql.DataSource"
               maxActive="100" maxIdle="2" maxWait="5000"
               username="myuser" password="mypass" driverClassName="com.sybase.jdbc3.jdbc.SybDriver"
               url="jdbc:sybase:Tds:ouaga:5000/MyBase</Context>

Au moment de récuppérer l'URL on pourra avoir de problèmes de classpath, dans ce ca le mettre dans les librairies commns de tomcat

Dans le cas d'une utilisation au sein de Spring. Le fichier dao-context.xml a été modifié pour utiliser les datasources

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"
        destroy-method="close">
        <property name="jndiName" value="java:comp/env/jdbc/my-datasource" />
</bean>

Cette datasource se définit dans le fichier context.xml de votre serveur tomcat de eclipse, préciser la datasource.

<Context path="/myapp" docBase="myapp-ihm"
        debug="5" reloadable="true" crossContext="true">
    
  <Resource name="jdbc/my-datasource" auth="Container" type="javax.sql.DataSource"
               maxActive="100" maxIdle="30" maxWait="10000"
               username="user" password="password" driverClassName="com.mysql.jdbc.Driver"
               url="jdbc:mysql://localhost:3306/mydb"/>
</Context>

Ensuite copier la librairie connector-mysql (Z:\00-DOSSIER_PROD\DEquipe\Produits\Poste dev\mysql-connector-java-5.0.5.jar ). Dans votre répertoire lib de tomcat

A l'issue de ces manipulations, un clean et une publication seront prudent.

Installer des datasources sous JONAS

Dans le fichier conf/jonas.properties de votre serveur d'application, ajouter les datasources séparée par des virgules :

jonas.service.dbm.datasources    my_datasource1

Créer le fichier
my_datasource1.properties dans votre répertoire conf et y ajouter les propriétés de votre datasources

#This file is generated by JOnAS
#Fri Feb 26 14:16:50 CET 2010
jdbc.maxconpool=-1
jdbc.connmaxage=1440
jdbc.maxwaittime=10
datasource.url=\ jdbc\:mysql\://my-db\:3306/mydb
datasource.description=no desc
datasource.mapper=rdb
jdbc.minconpool=0
jdbc.connteststmt=SELECT 1
datasource.username=myuser
datasource.name=ftjobs_1
datasource.classname=com.mysql.jdbc.Driver
jdbc.maxwaiters=1000
datasource.password=mypassword
jdbc.connchecklevel=1
jdbc.maxopentime=1440

Créer un fichier jonas-web dans le répertoire WEB-INF de votre application

<jonas-web-app>
<jonas-resource>
<res-ref-name>jdbc/my-datasource</res-ref-name>
<jndi-name>mydatasource_1</jndi-name>
</jonas-resource>
</jonas-web-app>

Comment définir le niveau des source JSP

Dans le fichier conf/web.xml on règle le source level

<pre class="text">   <servlet>
      <servlet-name>jsp</servlet-name>
      <servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
      <init-param>
          <param-name>fork</param-name>
          <param-value>false</param-value>
      </init-param>
       <init-param>
               <param-name>compilerSourceVM</param-name>
                  <param-value>1.5</param-value>
                 </init-param>
  <init-param>
      <param-name>compilerTargetVM</param-name>
      <param-value>1.5</param-value>
   </init-param>
   <init-param>
          <param-name>xpoweredBy</param-name>
          <param-value>false</param-value>
      </init-param>
      <load-on-startup>3</load-on-startup>
  </servlet>

http://tomcat.apache.org/tomcat-5.5-doc/jasper-howto.html

Récupérer un objet dans un annuaire JNDI

Ceci est un fichier contexte exemple qui permet de définir une ressource

<Context displayName="web-service server" docBase="/opt/tomcat/webapps/myservice" path="/myservice" workDir="work/Catalina/localhost/myservice">
<Environment description="" name="pathDepot" type="java.lang.String" value="/var/depot-ws/myservice"/>
<Environment description="" name="facteurAttente" type="java.lang.Integer" value="0"/>
</Context>

Dans le fichier web.xml, il faut utiliser ce code

<env-entry>
    <env-entry-name>docPath</env-entry-name>
    <env-entry-value>c:/doc/doc1</env-entry-value>
    <env-entry-type>java.lang.String</env-entry-type>
</env-entry>

Je propose un bout de code pour récupérer un objet dans un annuaire JNDI.

        Context initialContext = null;
        try {
            initialContext = new InitialContext();
            pathDepot = (String) initialContext
                    .lookup("java:comp/env/pathDepot");
            facteurDattente = (Integer) initialContext
                    .lookup("java:comp/env/facteurAttente");
        } catch (Exception e) {
            log.debug("Cannot get initial context for JNDI: ");
            log.debug(e);
        }

Installer son tomcat

Installer son tomcat

Maintenant que nous avons vu la théorie, il est temps de commencer la pratique. Avant de commencer il peut être bon de vous avertir que les opérations à venir ne prennent pas une demi heure. Ne vous attendez donc pas à voir fonctionner l'application de démonstration dans le quart d'heure à venir.

Tomcat

Installation

Tomcat est un chef d'oeuvre de simplicité à installer

Pour nos expériences nous allons nous servir de la version 5 du serveur, bien qu'il ne s'agisse pas encore de la version la plus répandue du serveur, elle peut servir dans un contexte de production :

http://jakarta.apache.org/ est l'url de référence pour tous les projets sous licence apache. Bien que cette page puisse sembler relativement austère, beaucoup de composants JAVA de Jakarta ont su s'imposer sur le marché. On y trouve entre autre tomcat et struts :

Tomcat : http://jakarta.apache.org/tomcat

Struts : http://stuts.apache.org/

Cliquez sur le liens download binaries et cherchez tomcat et struts. Comme c'est du code open source, prennez l'habitude, à chaque fois que vous téléchargez un programme pour le developpement d'également télécharger son code source. C'est lavantage de l'open source, un petit coup d'oeil dans le code source vous épargnera peut-être des heures et des heures de tatonnement irrationnels comme cela se produit dans les Apis propriétaires. Vérifiez bien que les versions binaires correspondent au sources.

Note :

Si l'envie folle vous prend de procéder à l'ancienne :"Je compile mon projet". Sachez que les dépendances pour les constructions tomcat sont abracadabrantesques et rappelez vous que le java est portable, c'est donc sans bénéfice pour la performance mais cela vous permettra de debugger et de placer des trace dans le code source. Dézzipper votre tomcat à l'endroit ou vous souhaitez le voir s'exécuter. Par défaut, tomcat n'écrira que dans des sous répertoires de son répertoire racine.

Affectez une variable JAVA_HOME sur le chemin de votre JDK (Pas JRE) en cliquant sur le bouton droit droit sur le poste de travail dans windows.

Placez vous dans le répertoire de tomcat/bin et lancez la commande startup.sh startup.bat suivant que vous vous trouvez sur Linux ou sur Windows. Vous venez d'installer Tomcat. Félicitations !

Maintenant vous pouvez voir le résultat :

http://localhost:8080/

Note :

Il est possible que votre OS fournissent une distribution de Tomcat avec des chemins d'installation diffèrents de ceux par proposé par défault. Je recommande plutôt d'utiliser une arborescence identique à celle qui est proposée dans l'archive de la fondation apache tant qu'il s'agit de développement.

Voici ce que vous devez voir.

Installer les options d'administration

Pour pouvoir contrôler tomcat à distance il est nécessaire d'activer les utilisateurs d'administration. Placez vous dans le répertoire $TOMCAT_HOME/conf

Editez le fichier tomcat-users.xml pour qu'il ressemble à ceci :

Redémarrez tomcat et connectez vous à l'URL. Il vous affiche le manager d'application qui vous permet de lister et de contrôler les différentes applications déployées sur le serveur.

http://localhost:8080/manager/html

Installer Eclipse

Eclipse se télécharge ici : Installez la version 3.0.

http://www.eclipse.org

Comme nous allons nous servir de tomcat, nous allons utiliser le plugin Sysdeo qui permet de contrôller tomcat à travers eclipse. Pour installer le plugin, dezippez simplement l'archive dans l'arborescence de eclipse et relancez eclipse

http://www.sysdeo.com/eclipse/tomcatPlugin.html

Configurez le pluggin dans le menu préférences afin qu'il sache dialoguer avec tomcat.

Nous sommes prêt à travailler sur une application réelle.

L'application de démonstration

L'application de démonstration nous présente une application relativement complexe où vous pourrez retrouver beaucoup des problèmes que l'on peu rencontrer dans le web. Elle présente les notions de :

• Connection à une base de données
• Login et Enregistrement d'utilisateur
• Utilisation du controleur Strut pour le contrôleur
• Internationalisation (Charset et détection)
• Gestion de formulaire dynamique
• Boucle de traitement simple et imbriquée
• Sécurisation de la partie administration

Téléchargez l'application de démonstration ici. Elle se présente sous la forme d'une archive WEB (.war) qui est en fait un zip ou les fichiers se trouvent organisé d'une manière spéciale. Pour la déployer il suffit de la copier dans le répertoire webapp de tomcat, l'extraction des fichiers se fait automatiquement.

Maintenant quand vous vous connecter sur l'application manager vous devez appercevoir l'application QuizzTomcat dans la liste.

Cependant, cette application s'appuie sur une base de donnée et il faut l'installer ! Courage c'est presque fini !

Installation de MySQLpour l'application de démonstration

Téléchargez mysql en vesion 4.0 ici

Dans le répertoire c:\mysql\bin lancez winmysqladmin et installez MySQL en temps que service. Lancez en ligne de commande le programme

mysql -uroot

Vous êtes l'utilisateur d'administration. Maintenant nous allons créer la database et donner les droit à l'utilisateur quizz d'accéder à cette database.

mysql>create database quizz;
mysql>grant all privileges on quizz.* to quizz@localhost identified by 'quizz';
mysql>use quizz;

Nous allons créer les tables nécessaires à l'application de démonstration avec le fichier quizz.dmp qui se trouve dans QuizzTomcat/WEB-INF/sql/quizz.dmp à l'intérieur de la WebApp.

Suit une volée d'insultes et peut-être des bip si votre ordinateur est un bavard.

Voila la base de données est initialisée.

Configuration de l'application WEB

Maintenant, prennez le fichier jar qui se trouve dans WEB-INF/lib/mysql-connector-bin.jar et copier le dans le répertoire tomcat/common/lib.

Connectez vous à la console d'administration de tomcat et tapez le user et le mot passe tomcat pour vous connecter.

Placez vous sur Service->Host->Context(QuizzTomcat)->DataSource et selectionnez Create a new DataSource. Et rentrez les paramètres de la data source. Sauvez et commit les changements.

Pour vérifier que tout s'est bien passé, il faut aller voir dans le fichier TOMCAT_HOME/conf/Catalina/localhost/QuizzTomcat.xml qui est le fichier de contexte.

Il doit avoir l'allure suivante :

 <context displayname="Quizz App" docbase="C:\Documents and    Settings\Propriétaire\Bureau\eclipse\workspace\QuizzTomcat" path="/QuizzTomcat" reloadable="true" workdir="C:\Documents    and Settings\Propriétaire\Bureau\eclipse\workspace\QuizzTomcat\work">
 <resource name="jdbc/Quizz" type="javax.sql.DataSource">
 <resourceparams name="jdbc/Quizz">
 <parameter>
 <name>maxWait</name>
 <value>5000</value>
 </parameter>
 <parameter>
 <name>maxActive</name>
 <value>4</value>
 </parameter>
 <parameter>
 <name>password</name>
 <value>quizz</value>
 </parameter>
 <parameter>
 <name>url</name>
 <value>jdbc:mysql://localhost/quizz?autoReconnect=true</value>
 </parameter>
 <parameter>
 <name>driverClassName</name>
 <value>org.gjt.mm.mysql.Driver</value>
 </parameter>
 <parameter>
 <name>maxIdle</name>
 <value>2</value>
 </parameter>
 <parameter>
 <name>username</name>
 <value>quizz</value>
 </parameter>
 </resourceparams>
 <resourcelink global="UserDatabase" name="users" type="org.apache.catalina.UserDatabase">
 </resourcelink></resource></context>

Avant de commencer à rentrer dans le détail du code dans le chapitre suivant, il serait bon que vous parcouriez l'application de démonstration QuizzTomcat

Note :

L'application de démonstration ne resemble pas à ce qu'on pourrait appeler un Tutorial, pour deux raisons

• D'abord, en ne restant que sur des applications simples, on se préserve des questions qui font mal quand on passe au réel .
• Ce cours est fait pour être détaillé de vive voix.