Tomcat Dentro del Servidor Web (Windows)
Configruaciones Soportadas
Para la operación "en-proceso" tendremos que usar los redirectores Netscape/IIS. Debemos mirar a su soporte de configuraciones soportadas.
El adaptador en-proceso se ha probado usando JDK 1.1.7b, JDK 1.1.7 de IBM, JDK 1.1.8, JDK 1.2.2., y JDK 1.3.
Instalación
Como con Tomcat 3.2, hay una versión pre-construida del adapador en-proceso jni_connect.dll, bajo el directorio win32/i386 de donde nos bajamos la
distribución binaria de Tomcat. Para aquellos que usan Netscape como navegador, intentar descargar una versión Zip del fichero, si está disponible. Puede haber problemas usando Netscape para descargar ficheros DLL.
El adaptador JNI de Tomcat requiere las siguientes acciones:
- Poner jni_connect.dll en el directorio bin - jni_connect.dll es usado para realizar llamadas desde Tomcat al servidor web.
- Actualizar workers.properties y añadimos el worker JNI - El wroker JNI necesita varios ítems de configuración, y necesitaremos añadirlos al fichero de propiedades del worker.
- Actualizar server.xml - Necesitamos instruir a Tomcat para usar los controladores de conexiones JNI. También necesitaremos proporcionar la propiedad home para nuestro ContextManager (después crearemos bajo este directorio los ficheros de log y los directorios de trabajo).
- Direccionar contexto(s) al Tomcat en-proceso - necesitamos instruir al redirecionador para que envíe trabajo al Tomcat en--proceso.
- Re-arrancamos nuestro servidor (para que los cambios tengan efecto)
Poner jni_connect.dll bajo el directorio bin
Poenemos jni_connect.dll dentro de <tomcat_home>\bin\win32\i386\.
Actualizar workers.properties y añadir el worker JNI
Deberíamos proporcionarle al worker JNI varias configuraciones, algunas son obligatorias y otras son una opción:
Nota:
Las siguientes instrucciones asumen que Tomcat está instalado en c:\jakarta-tomcat. Debemos ajustarlas de forma apropiada a nuestro directorio de instalación.
- Deberíamos definir un worker JNI.
Configuramos la propiedad worker.list para que apunte a un worker llamado jni: worker.list=jni
Anunciamos que el worker llamado jni es del tipo jni: worker.jni.type=jni
- Deberíamos configurar un classpath para usarlo en el Tomcat en-proceso.
Para configurar el classpath usamos la propiedad worker.name.class_path,por ejemplo:
worker.jni.class_path=c:\jakarta-tomcat\classes
worker.jni.class_path=c:\jakarta-tomcat\lib\jaxp.jar
worker.jni.class_path=c:\jakarta-tomcat\lib\parser.jar
worker.jni.class_path=c:\jakarta-tomcat\lib\jasper.jar
worker.jni.class_path=c:\jakarta-tomcat\lib\servlet.jar
worker.jni.class_path=c:\jakarta-tomcat\lib\webserver.jar
worker.jni.class_path=c:\jdk1.2.2\lib\tools.jar
Nota: No debemos olvidar incluir tools.jar den JDK en nuestro classpath.
- Deberíamos proporcionar un path completo a la implementación dll de la JVM. Para JDK1.1.x es javai.dll, para JDK1.2.x es jvm.dll. Por ejemplo:
worker.jni.jvm_lib=c:\jdk1.2.2\jre\bin\classic\jvm.dll
- Deberíamos proporcionar opciones de la línea de comandos para tomcat; debemos proporcionar una opción -config para especificar nuestro server.xml configurado JNI. Por ejemplo:
worker.jni.cmd_line=-config
worker.jni.cmd_line=c:\jakarta-tomcat\conf\jni_server.xml
Nota: El string cmd_line no soporta espacios embebidos. Si el path al fichero jni_server.xml incluye espacios, debemos usar el nombre DOS 8.3 para los directorios que contienen espacios en sus nombres.
- Deberíamos especificar la localización del home de Tomcat como una propiedad del sistema Java. Por ejemplo:
worker.jni.sysprops=tomcat.home=c:\jakarta-tomcat
- Podemos especificar propiedades de sistema Java adicionales. Por ejemplo:
worker.jni.sysprops=java.compiler=NONE
- Podemos especificar ficheros para ser usados por stdout y stderr de la JVM. Por ejemplo:
worker.jni.stdout=c:\jakarta-tomcat\logs\jvm.stdout
worker.jni.stderr=c:\jakarta-tomcat\logs\jvm.stderr
- Podemos especificar una PATH adicional, para usarlo cuando se carguen las dlls (útil cuando estámos usando código nativo). Por ejemplo:
worker.jni.ld_path=c:\SQLLIB\bin
worker.jni.ld_path=c:\my\native\code
Podemos encontrar un fichero de ejemplo (jni_workers.properties) bajo el directorio jakarta-tomcat/conf. Los contenidos de este fichero asumen que Tomcat está instalado en c:\jakarta-tomcat.
Actualizar server.xml
Por defecto Tomcat lee el fichero <tomcat_home>\conf\server.xml. Este fichero define entre otras cosas los contextos y conectores usados por Tomcat. Para poder trabajar en-proceso tendremos que realizar las siguientes acciones:
- Deberíamos actualizar la lista de conectores.
Eliminar todos los conectores de nuestro server.xml y añadir las siguientes líneas (observa que no necesitamos actualizar el área marcada con <tomcat_home>)
<!-- JNI connector, make sure that you update the native_lib
Parameter to point to your jni_connect.dll
-->
<Connector className="org.apache.tomcat.service.JNIEndpointConnector">
<Parameter name="native_lib"
value="<tomcat_home>/bin/win32/i386/jni_connect.dll"/>
</Connector>
Estas líneas añaden un conector JNI a Tomcat.
- Deberíamos actualizar el atributo home usado por el ContextManager para que sepa donde situar los directorios log, work y webapps. Por ejemplo:
<ContextManager debug="0" workDir="work" home="<tomcat_home>" />
.
.
.
</ContextManager />
Podemos encontrar un fichero de ejemplo (jni_server.xml) bajo jakarta-tomcat/conf.
Redirigir Contextos hacia los Workers JNI
Necesitaremos seleccionar los contextos que deseamos servir usando nuestro worker jni.
Sobre Netscape podemos hacer esto modificando las líneas en el objeto de configuración del servlet para que reflejen el trabajo redirigido al nuevo worker JNI. Por ejemplo:
<Object name=servlet>
ObjectType fn=force-type type=text/plain
Service fn="jk_service" worker="jni"
</Object>
Sobre IIS tendremos que modificar nuestro fichero de montaje del worker para montar los contextos del worker JNI. Por ejemplo
/examples/*=jni
Cuando lo hayamos hecho debemos re-arrancar el servidor. Esto es todo, ahora podemos ejecutar Tomcat en-proceso.
Construir el conector dll JNI
El conector JNI fue desarrollado usando Visual C++ Ver.6.0, por eso tener este entorno es un prerrequisito si queremos realizar una construcción personalizada. También necesitaremos una instalación del JDK (el jre no es suficiente) para usar los ficheros includes del JDK.
Los pasos que necesitamos realizar son:
- Cambiar al directorio del código fuente del conector.
- Asegurarnos de que la variable de entorno JAVA_HOME apunta a nuestra instalación del JDK.
- Ejecutar el siguiente comando:
MSDEV jni_connect.dsp /MAKE ALLL
Si msdev no está en nuestro path, debemos introducir el path completo a msdev.exe.
Esto construye tanto la versión liberada como de depuración del conector JNI.
Una alternativa sería abrir el fichero de espacio de trabajo (jni_connect.dsw) en msdev y construirlo usando el menú build.
¿Cómo funciona esto?
Tabajar "en-proceso" requiere tanto el servidor redireccionador (IIS-Tomcat/Netscape-Tomcat) como el conector en-proceso. El servidor puede dirigir el trabajo a diferentes workers basándose en sus nombres; ahora que hemos creado el worker JNI el servidor redireccionador puede reenviarle trabajo...
La operación básica es:
- Durante la inicialización el servidor redireccionador arrancar el worker JNI
- Después de la arrancada el worker JNI crea una JVM dentro del servidor web y arranca Tomcat en ella.
- Por cada petición entrante para un servlet, el servidor chequeará qué worker es responsable del contexto específico. Si este worker es el worker JNI se le asigna la petición.
- El worker JNI adjunta a la JVM y envía la petición dentro del motor Tomcat (usando el JNIEndpointConnector). Entonces Tomcat ejecutará la petición.
- El servidor recoge la respuesta desde el worker JNI y se la devuelve al navegador.
Tutoriales
