Integrating Tomcat and Apache on Red Hat Linux

Referance:  http://www.meritonlinesystems.com/docs/apache_tomcat_redhat.html

1.0 Introduction

Java servlets are a powerful tool for building websites and web based applications. One skill that every Java web developer should have is the ability to install and configure the Tomcat servlet engine. Many thanks to the Apache Software Foundation for providing this mature, stable, open source software. It was recently voted the Best Application Server of 2003 by InfoWorld readers.

This article discusses how to integrate Tomcat with the Apache web server on Red Hat Linux 9 or Red Hat Enterprise Linux 3. The goal is to provide a simple, stable configuration that will allow users to gain confidence using Tomcat in a development environment. Setting up a production Tomcat server is outside the scope of this article.

Please note the following conventions:

• All commands are issued as root unless otherwise noted.
• {YOUR_DOMAIN} and {YOUR_APPLICATION} are placeholder values that should be customized to your setup. For example, {YOUR_DOMAIN} might be “localhost.test” and {YOUR_APPLICATION} might be “test”.

2.0 Installing Apache

I chose to install Apache using the Red Hat RPM. Using the RPM instead of compiling Apache from source simplifies system administration in the following ways:

• Updates and bug fixes can be installed automatically from the Red Hat Network.
• Startup and shutdown scripts are already configured and available.

I recommend using the Red Hat up2date command line utility to install Red Hat RPMs. It eliminates a multitude of headaches by ensuring the software you install is the correct version and you have the right dependencies installed on your system.

Install the following Red Hat RPMs if they are not already installed:

• httpd: the Apache web server
• httpd-devel: development tools that will be needed to create the mod_jk connector

To install these packages using up2date, make sure you are connected to the Internet, and enter the following:

 

up2date -i httpd httpd-devel

You should now be able to start/stop/restart Apache as follows:

 

service httpd start
service httpd stop
service httpd restart

Verify that Apache is working by starting Apache and typing http://localhost/ into your browser. You should see the default Apache install page with links to documentation.

3.0 Installing Tomcat

The only requirements to run Tomcat are that a Java Development Kit (JDK), also called a Java Software Development Kit (SDK), be installed and the JAVA_HOME environment variable be set.

3.1 Java SDK

I chose to install Sun’s Java 2 Platform, Standard Edition, which can be downloaded from http://java.sun.com/j2se/). I chose the J2SE v1.4.2 SDK Linux self-extracting binary file.

Change to the directory where you downloaded the SDK and make the self-extracting binary executable:

 

chmod +x j2sdk-1_4_2-linux-i586.bin

Run the self-extracting binary:

 

./j2sdk-1_4_2-linux-i586.bin

There should now be a directory called j2sdk1.4.2 in the download directory. Move the SDK directory to where you want it to be installed. I chose to install it in /usr/java. Create /usr/java if it doesn’t exist. Here is the command I used from inside the download directory:

 

mv j2sdk1.4.2 /usr/java

Set the JAVA_HOME environment variable, by modifying /etc/profile so it includes the following:

 

JAVA_HOME="/usr/java/j2sdk1.4.2"
export JAVA_HOME

/etc/profile is run at startup and when a user logs into the system, so you will need to log out and log back in for JAVA_HOME to be defined.

 

exit
su -

Check to make sure JAVA_HOME is defined correctly using the command below. You should see the path to your Java SDK.

 

echo $JAVA_HOME

3.2 Tomcat Account

You will install and configure Tomcat as root; however, you should create a dedicated group and user account for Tomcat to run under as follows:

 

groupadd tomcat
useradd -g tomcat tomcat

3.3 Download Tomcat

Download the latest release binary build from http://www.apache.org/dist/jakarta/tomcat-5/. Since Tomcat runs directly on top of a standard JDK, I cannot think of any reason to building it from source. There are a number of different download formats. I chose the gnu zipped tar file (jakarta-tomcat-5.0.28.tar.gz).

3.4 Tomcat Standalone

Unzip Tomcat by issuing the following command from your download directory:

 

tar xvzf jakarta-tomcat-5.0.28.tar.gz

This will create a directory called jakarta-tomcat-5.0.28. Move this directory to wherever you would like to install Tomcat. I chose /usr/local. Here is the command I issued from inside the download directory:

 

mv jakarta-tomcat-5.0.28 /usr/local/

The directory where Tomcat is installed is referred to as CATALINA_HOME in the Tomcat documentation. In this installation CATALINA_HOME=/usr/local/jakarta-tomcat-5.0.28.

I recommend setting up a symbolic link to point to your current Tomcat version. This will save you from having to make changes to startup and shutdown scripts each time you upgrade Tomcat. It also allows you to keep several versions of Tomcat on your system and easily switch amongst them. Here is the command I issued from inside /usr/local to create a symbolic link called /usr/local/jakarta-tomcat that points to /usr/local/jakarta-tomcat-5.0.28:

 

ln -s jakarta-tomcat-5.0.28 jakarta-tomcat

Change the group and owner of the /usr/local/jakarta-tomcat and /usr/local/jakarta-tomcat-5.0.28 directories to tomcat:

 

chown tomcat.tomcat /usr/local/jakarta-tomcat
chown -R tomcat.tomcat /usr/local/jakarta-tomcat-5.0.28

It is not necessary to set the CATALINA_HOME environment variable. Tomcat is smart enough to figure out CATALINA_HOME on its own.

You should now be able to start and stop Tomcat from the CATALINA_HOME/bin directory by typing ./startup.sh and ./shutdown.sh respectively. Test that Tomcat is working by starting it and typing http://localhost:8080 into your browser. You should see the Tomcat welcome page with links to documentation and sample code. Verify Tomcat is working by running some of the examples.

4.0 Installing the Connector

4.1 Connector Benefits

At this point, Apache and Tomcat should be working separately in standalone mode. You can run Tomcat in standalone mode as an alternative to Apache. In fact, in some cases, it is said that Tomcat standalone is faster than serving static content from Apache and dynamic content from Tomcat. However, there are the following compelling reasons to use Apache as the front end:

1. You can use Apache to buffer slow connections. Tomcat uses java.io, which uses a thread for each request, so Tomcat can run out of connections as the number of slow requests grows. This could be an issue if your application supports a large number of dial-up users.
2. You can use a connector such as mod_jk to load balance amongst several Tomcat instances.
3. You can take advantage of Apache features such as cgi and PHP.
4. You can take advantage of Apache modules such as mod_rewrite, mod_headers, and mod_expire.
5. You can isolate virtual hosts in their own Tomcat instances.

The increased functionality obtained by using Apache on the front end can outweigh the effort required to install and configure a connector.

4.2 Selecting a Connector

Development on the mod_jk2 connector was discontinued on 11/15/2004; therefore, you no longer have to decide between the mod_jk and mod_jk2 connectors. Use the mod_jk connector. It has been around a long while and is very stable.

4.3 Building the mod_jk Connector

The mod_jk connector is the communication link between Apache and Tomcat. It listens on a defined port for requests from Apache and forwards those requests to Tomcat.

Install the following Red Hat RPMs if they are not already installed:

• libtool
• automake
• autoconf

Download the jk connector source from http://www.apache.org/dist/jakarta/tomcat-connectors/jk/. I used jakarta-tomcat-connectors-1.2.8-src.tar.gz.

Unzip the contents of the file into your download directory as follows:

 

tar xvzf jakarta-tomcat-connectors-1.2.8-src.tar.gz

This will create a folder called jakarta-tomcat-connectors-1.2.8-src. Move this folder to wherever you store source files on your system. I chose /usr/src. Here is the command I issued from inside the download directory:

 

mv jakarta-tomcat-connectors-1.2.8-src /usr/src

I refer to the folder where the connector source is installed as CONN_SRC_HOME. In my case CONN_SRC_HOME = /usr/src/jakarta-tomcat-connectors-1.2.8-src.

Change to directory CONN_SRC_HOME/jk/native and run the buildconf.sh script as follows:

 

./buildconf.sh

This will create the CONN_SRC_HOME/jk/native/configure file. Run the configure script with the path to the apxs file on your system. If you installed Apache using the Red Hat RPM, apxs should be located at /usr/sbin/apxs.

 

./configure --with-apxs=/usr/sbin/apxs

Build mod_jk with the following command:

 

make

If you see missing object errors, try this alternate command:

 

make LIBTOOL=/etc/httpd/build/libtool

If all went well, the mod_jk.so file was successfully created. Manually copy it to Apache’s shared object files directory:

 

cp CONN_SRC_HOME/jk/native/apache-2.0/mod_jk.so /etc/httpd/modules

5.0 Creating the Application Directories

Both Apache and Tomcat application files will be installed under the /home/tomcat/webapps directory. This setup will allow you to easily upgrade Tomcat and back up your application files.

Create your application directories as follows:

 

mkdir /home/tomcat/webapps
mkdir /home/tomcat/webapps/{YOUR_DOMAIN}
mkdir /home/tomcat/webapps/{YOUR_DOMAIN}/logs
mkdir /home/tomcat/webapps/{YOUR_DOMAIN}/{YOUR_APPLICATION}
mkdir /home/tomcat/webapps/{YOUR_DOMAIN}/{YOUR_APPLICATION}/WEB-INF
mkdir /home/tomcat/webapps/{YOUR_DOMAIN}/{YOUR_APPLICATION}/WEB-INF/classes

Set directory permissions as follows:

 

chmod 755 /home/tomcat/webapps
chmod 755 /home/tomcat/webapps/{YOUR_DOMAIN}
chmod 755 /home/tomcat/webapps/{YOUR_DOMAIN}/{YOUR_APPLICATION}

6.0 Configuring Tomcat

6.1 workers.properties

The workers.properties file contains information so mod_jk can connect to the Tomcat worker processes.

Place the following workers.properties file in the /etc/httpd/conf directory:

 

# workers.properties - ajp13
#
# List workers
worker.list=wrkr
#
# Define wrkr
worker.wrkr.port=8009
worker.wrkr.host=localhost
worker.wrkr.type=ajp13
worker.wrkr.cachesize=10
worker.wrkr.cache_timeout=600
worker.wrkr.socket_timeout=300

Notes

1. There is an example workers.properties file located in the CONN_SRC_HOME/jk/conf directory. The example file provides a lot of useful information and insight into the workers.properties file, but it contains so much information that it can be confusing. I recommend using it as a learning tool but creating your own workers.properties file from scratch.
2. The configuration above assumes Apache and Tomcat are located on the same box and requests are forwarded to Tomcat using type ajp13 workers. Type ajp13 workers forward requests to out-of-process Tomcat workers using the ajpv13 protocol over TCP/IP sockets.
3. The name of the worker in the JkMount directive in httpd.conf must match the name of the worker in worker.list (“wrkr” in the configuration above).

6.2 server.xml

The CATALINA_HOME/conf/server.xml file contains Tomcat server configuration information. The default server.xml is great for verifying that Tomcat works in standalone mode and for viewing the examples that come with the application, but it contains so much information that it can be confusing. I recommend saving it for future reference and creating a new server.xml.

Save the default server.xml as follows:

 

mv CATALINA_HOME/conf/server.xml CATALINA_HOME/conf/server.xml.orig

Copy the following into a new server.xml file:

 

<Server port="8005" shutdown="0fbb9aebcbfbef203eca71b6be367859" debug="0">

	<Service name="Tomcat-Apache">

		<Connector address="127.0.0.1"
			port="8009"
			minProcessors="5"
			maxProcessors="75"
			enableLookups="false"
			protocol="AJP/1.3"
			debug="0"/>

		<Engine name="appserver"
			debug="0"
			defaultHost="{YOUR_DOMAIN}">

			<Host name="{YOUR_DOMAIN}"
				appBase="/home/tomcat/webapps"
				autoDeploy="false"
				deployOnStartup="false"
				unpackWARs="false"
				deployXML="true"
				debug="0"/>

		</Engine>

	</Service>

</Server>

If you do keep the default server.xml, make sure you comment out any other connectors besides mod_jk that are listening on port 8009. The default file comes with the Coyote/JK2 connector enabled for the Tomcat-Standalone service. This will conflict with the mod_jk connector in your Tomcat-Apache service. You should comment this connector out. It isn’t needed when you connect directly to Tomcat in standalone mode (port 8080), so I’m not sure why this connector is enabled by default.

The Connector address defines the interface that Tomcat will listen on for mod_jk requests from Apache. In my configuration, Apache and Tomcat reside on the same box, so I have set the address to the loopback address. The default is for Tomcat to listen on all interfaces, so restricting it to the loopback interface improves security.

The Server shutdown property is the text string that is sent over a socket connection to stop Tomcat. The default value is “SHUTDOWN”. The shutdown port is always on the loopback interface, which provides host-level protection. However, there is the possibility that the host could be compromised and someone could send the command SHUTDOWN to all ports and knock Tomcat offline. To prevent this, replace the default value with one that is difficult to guess. Do not use the example string above. Create your own by feeding random bytes into md5sum as follows:

 

head -1024c /dev/random | md5sum

Change the permissions on server.xml to prevent unprivileged users from reading the shutdown string:

 

chmod 600 CATALINA_HOME/conf/server.xml

6.3 Configuring the Context

It is recommended that contexts be defined in separate files, not in server.xml. The context configuration directory has the same name as the Engine in server.xml.

Create the context configuration directory as follows:

 

mkdir CATALINA_HOME/conf/appserver

The host context configuration directory has the same name as the corresponding Host in server.xml.

Create the context configuration directory for your domain as follows:

 

mkdir CATALINA_HOME/conf/appserver/{YOUR_DOMAIN}

Create the context configuration file as follows:

 

touch CATALINA_HOME/conf/appserver/{YOUR_DOMAIN}/{YOUR_APPLICATION}.xml

Copy the following text into {YOUR_APPLICATION}.xml:

 

<Context path=""
	docBase="{YOUR_APPLICATION}"
	reloadable="true"
	debug="0"/>

Setting the Context reloadable property to true tells Tomcat to automatically load new and changed application class files found in /WEB-INF/classes and /WEB-INF/lib. This feature is very useful during development. However, it is recommended to set reloadable to false in production environments because monitoring class file changes requires significant server resources.

6.4 log4j

Download the latest log4j and install log4j.jar in CATALINA_HOME/common/lib.

Download the latest commons logging and install commons-logging.jar in CATALINA_HOME/common/lib.

Create a file called log4j.properties as follows and place it in the CATALINA_HOME/common/classes directory:

 

log4j.rootLogger=WARN, R
log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=/usr/local/jakarta-tomcat/logs/tomcat.log
log4j.appender.R.MaxFileSize=10MB
log4j.appender.R.MaxBackupIndex=10
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%d{DATE} - %p %c - %m%n
log4j.logger.org.apache.catalina=WARN, R

7.0 Configuring Apache

Apache is configured with directives placed in the main Apache configuration file, /etc/httpd/conf/httpd.conf. In addition, Apache 2 has configuration files for perl, php, and ssl located in /etc/httpd/conf.d/.

Rename the /etc/httpd/conf.d/ssl.conf file to ssl.conf.bak. The default Red Hat Apache 2 installation comes with ssl support enabled. If ssl is needed, you can re-enable it after you have successfully integrated Apache and Tomcat.

7.1 httpd.conf

You will notice that there are three sections labeled in the httpd.conf file supplied by Red Hat: (1) Global Environment, (2) Main Server Configuration, and (3) Virtual Hosts.

Add the following to the bottom of the existing LoadModule directives in the Global Environment section:

 

LoadModule jk_module modules/mod_jk.so

Add the following to the bottom of the Main Server Configuration section:

 

JkWorkersFile "/etc/httpd/conf/workers.properties"
JkLogFile "/etc/httpd/logs/mod_jk.log"
JkLogLevel info
JkLogStampFormat "[%a %b %d %H:%M:%S %Y]"

Set up a Virtual Host directive in the Virtual Hosts section of httpd.conf. Below is an example of how to set up the {YOUR_DOMAIN} website so Tomcat handles all jsp pages and requests with “servlet” in the path:

 

NameVirtualHost 127.0.0.1:80

<VirtualHost 127.0.0.1:80>
	ServerAdmin webmaster@{YOUR_DOMAIN}
	ServerName {YOUR_DOMAIN}
	DocumentRoot /home/tomcat/webapps/{YOUR_DOMAIN}/{YOUR_APPLICATION}
	ErrorLog /home/tomcat/webapps/{YOUR_DOMAIN}/logs/error_log
	CustomLog /home/tomcat/webapps/{YOUR_DOMAIN}/logs/access_log common
	JkMount /*.jsp wrkr
	JkMount /servlet/* wrkr
	# Deny direct access to WEB-INF
	<LocationMatch ".*WEB-INF.*">
		AllowOverride None
		deny from all
	</LocationMatch>
</VirtualHost>

The argument for the NameVirtualHost directive must match exactly the argument for the VirtualHost directive (127.0.0.1:80).

The JkMount directive specifies url patterns of requests that will be forwarded to Tomcat for processing.

You can test your Apache configuration by typing the following:

 

httpd -t -D DUMP_VHOSTS

You should get something like the following response:

 

127.0.0.1:80           is a NameVirtualHost
         default server {YOUR_DOMAIN} (/etc/httpd/conf/httpd.conf:1056)
         port 80 namevhost {YOUR_DOMAIN} (/etc/httpd/conf/httpd.conf:1056)
Syntax OK

8.0 Setting Up {YOUR_DOMAIN}

{YOUR_DOMAIN} does not need to be a domain name with a DNS entry. For testing purposes, you can set up any domain you want in the /etc/hosts file of the machine that you will be using to access your application.

The example below shows the entry for {YOUR_DOMAIN} when running Apache and Tomcat on a single machine, typical for a development computer.

 

127.0.0.1	{YOUR_DOMAIN}

9.0 Testing Apache

We will create and install a simple Hello World html page so we can test to make sure Apache handles requests for static html pages.

9.1 Hello World HTML

Copy the following text into a file called HelloWorld.html and install the file in the /home/tomcat/webapps/{YOUR_DOMAIN}/{YOUR_APPLICATION} directory.

 

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Hello World HTML!</title>
</head>
<body>
<h1>Hello World HTML!</h1>
</body>
</html>

If Apache has not been restarted since you added your virtual host, do so as follows:

 

service httpd restart

You should now be able to type http://{YOUR_DOMAIN}/HelloWorld.html into your browser and see the always-exciting “Hello World” message.

10.0 Testing Tomcat

We will create and install a simple Hello World jsp page and servlet so we can test to make sure Apache forwards servlet requests to Tomcat for handling.

10.1 Hello World JSP

Copy the following text into a file called HelloWorld.jsp and install the file in the /home/tomcat/webapps/{YOUR_DOMAIN} directory.

 

<%@ page contentType="text/html;charset=WINDOWS-1252"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
<title>Hello World JSP</title>
</head>
<body>
<h1><% out.println(" Hello World JSP!"); %></h1>
</body>
</html>

10.2 Hello World Servlet

Copy the following into a file called HelloWorld.java:

 

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld
    extends HttpServlet {
    public void doGet(HttpServletRequest request, 
                       HttpServletResponse response)
                throws IOException, ServletException {

		response.setContentType("text/html");
		PrintWriter out = response.getWriter();

		out.println("Hello World Servlet!");

	}

}

Compile the source into a class file as follows:

 

javac -classpath /usr/local/jakarta-tomcat/common/lib/servlet.jar HelloWorld.java

This will create a file called HelloWorld.class. Copy the HelloWorld.class file to the /home/tomcat/webapps/{YOUR_DOMAIN}/{YOUR_APPLICATION}/WEB-INF/classes directory.

10.3 Tomcat Application

The web.xml file is where a servlet name is mapped to a URL pattern so Tomcat can run your servlet when requested. Below is the web.xml file that runs the HelloWorld servlet whenever the URL http://{YOUR_DOMAIN}/servlet/HelloWorld is entered in the browser:

 

<?xml version="1.0" encoding="ISO-8859-1"?>

<!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>

	<servlet>
		<servlet-name>HelloWorld</servlet-name>
		<servlet-class>HelloWorld</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>HelloWorld</servlet-name>
		<url-pattern>/servlet/HelloWorld</url-pattern>
	</servlet-mapping>

</web-app>

Restart Tomcat as follows:

 

/CATALINA_HOME/bin/shutdown.sh
/CATALINA_HOME/bin/startup.sh

Restart Apache as follows:

 

service httpd restart

You should now be able to type the following into your browser and see the always-exciting “Hello World” message:

http://{YOUR_DOMAIN}/HelloWorld.jsp

http://{YOUR_DOMAIN}/servlet/HelloWorld

11.0 Advanced Configuration

The following steps are not mandatory, but are suggested for a better, tighter Tomcat installation.

11.1 Tomcat Startup Script

If you want to automatically start Tomcat when your system boots and manage it using the service command as we do Apache, you must create an initialization script.

Copy the following text into a file called tomcat and install the file in the /etc/rc.d/init.d directory.

 

#!/bin/sh
#
# Startup script for Tomcat Servlet Engine
#
# chkconfig: 345 86 14
# description: Tomcat Servlet Engine
# processname: tomcat
# pidfile: /usr/local/jakarta-tomcat/bin/tomcat.pid
#

# User under which tomcat will run
TOMCAT_USER=tomcat

RETVAL=0

# start, debug, stop, and status functions
start() {
    # Start Tomcat in normal mode
    SHUTDOWN_PORT=`netstat -vatn|grep LISTEN|grep 8005|wc -l`
    if [ $SHUTDOWN_PORT -ne 0 ]; then
        echo "Tomcat already started"
    else
        echo "Starting tomcat..."
        chown -R $TOMCAT_USER:$TOMCAT_USER /usr/local/jakarta-tomcat/*
        chown -R $TOMCAT_USER:$TOMCAT_USER /home/tomcat/*
        su -l $TOMCAT_USER -c '/usr/local/jakarta-tomcat/bin/startup.sh'
	SHUTDOWN_PORT=`netstat -vatn|grep LISTEN|grep 8005|wc -l`
        while [ $SHUTDOWN_PORT -eq 0 ]; do
            sleep 1
            SHUTDOWN_PORT=`netstat -vatn|grep LISTEN|grep 8005|wc -l`
        done	
        RETVAL=$?
        echo "Tomcat started in normal mode"
        [ $RETVAL=0 ] && touch /var/lock/subsys/tomcat
    fi
}

debug() {
    # Start Tomcat in debug mode
    SHUTDOWN_PORT=`netstat -vatn|grep LISTEN|grep 8005|wc -l`
    if [ $SHUTDOWN_PORT -ne 0 ]; then
        echo "Tomcat already started"
    else
        echo "Starting tomcat in debug mode..."
        chown -R $TOMCAT_USER:$TOMCAT_USER /usr/local/jakarta-tomcat/*
        chown -R $TOMCAT_USER:$TOMCAT_USER /home/tomcat/*
        su -l $TOMCAT_USER -c '/usr/local/jakarta-tomcat/bin/catalina.sh jpda start'
	SHUTDOWN_PORT=`netstat -vatn|grep LISTEN|grep 8005|wc -l`
        while [ $SHUTDOWN_PORT -eq 0 ]; do
            sleep 1
            SHUTDOWN_PORT=`netstat -vatn|grep LISTEN|grep 8005|wc -l`
        done	
        RETVAL=$?
        echo "Tomcat started in debug mode"
        [ $RETVAL=0 ] && touch /var/lock/subsys/tomcat
    fi
}

stop() {
    SHUTDOWN_PORT=`netstat -vatn|grep LISTEN|grep 8005|wc -l`
    if [ $SHUTDOWN_PORT -eq 0 ]; then
        echo "Tomcat already stopped"
    else
        echo "Stopping tomcat..."
        su -l $TOMCAT_USER -c '/usr/local/jakarta-tomcat/bin/shutdown.sh'
	SHUTDOWN_PORT=`netstat -vatn|grep LISTEN|grep 8005|wc -l`
        while [ $SHUTDOWN_PORT -ne 0 ]; do
            sleep 1
            SHUTDOWN_PORT=`netstat -vatn|grep LISTEN|grep 8005|wc -l`
        done
	RETVAL=$?
        echo "Tomcat stopped"
        [ $RETVAL=0 ] && rm -f /var/lock/subsys/tomcat /usr/local/jakarta-tomcat/bin/tomcat.pid
    fi
}

status() {
    SHUTDOWN_PORT=`netstat -vatn|grep LISTEN|grep 8005|wc -l`
    if [ $SHUTDOWN_PORT -eq 0 ]; then
        echo "Tomcat stopped"
    else
        MODE="normal"
        JPDA_PORT=`netstat -vatn|grep LISTEN|grep 8000|wc -l`
        if [ $JPDA_PORT -ne 0 ]; then
            MODE="debug"
        fi
	echo "Tomcat running in $MODE mode"
    fi
}

case "$1" in
  start)
        start
        ;;
  debug)
        debug
        ;;
  stop)
        stop
        ;;
  restart)
        stop
        start
        ;;
  redebug)
        stop
        debug
        ;;
  status)
  	status
	;;
  *)
	echo "Usage: $0 {start|debug|stop|restart|redebug|status}"
	exit 1
esac

exit $RETVAL

Add the startup script to your system as follows:

 

chkconfig --add tomcat

The path of the file that contains the pid of the catalina startup java process can be set with the CATALINA_PID environment variable. CATALINA_HOME/bin/catalina.sh automatically calls a file called setenv.sh if it exists, so this is a good place to set environment variables.

Create setenv.sh as follows:

 

cd CATALINA_HOME/bin
touch setenv.sh
chmod 644 setenv.sh

Copy the following text into setenv.sh:

 

CATALINA_PID=/usr/local/jakarta-tomcat/bin/tomcat.pid

Now you will be able to start/stop/restart/status Tomcat using the following commands:

 

service tomcat start
service tomcat stop
service tomcat restart
service tomcat status

If you want Tomcat to start automatically when your system boots, you need to add tomcat to your runlevel as follows:

 

chkconfig --level 5 tomcat on

Runlevel 5 is the X Window System, typical for a development computer. Runlevel 3 is typical for a dedicated web server.

Apache and Tomcat can be started and restarted in any order. In the past (specifically with the 1.2.5 connector), if Tomcat was restarted, Apache would have to be restarted. This was because the AJP13 protocol maintains open sockets between Apache and Tomcat, and when Tomcat was restarted the connections would be hung in CLOSE_WAIT status until Apache was restarted. This has been fixed starting with the 1.2.6 connector.

11.2 Development Setup

During development, you will need access to your tomcat application directory. Add the user account under which you will be doing development to the tomcat group in /etc/group. For example, this is what the tomcat entry might look like in /etc/group if you do development under the yourname account:

 

tomcat:x:502:yourname

Make sure the tomcat group has permission to publish files (e.g. using ant) to your Tomcat application in /home/tomcat/webapps/{YOUR_DOMAIN}. Issue the following commands as root:

 

chmod g+x /home/tomcat
chmod -R g+rw /home/tomcat

12.0 Troubleshooting

12.1 Log Files To Watch

/home/tomcat/webapps/{YOUR_DOMAIN}/logs/error_log

Look here for clues to Apache httpd.conf configuration issues, for example VirtualHost setup.

CATALINA_HOME/logs/catalina.out

Look here for clues to Tomcat server.xml configuration issues. This file is written to when Tomcat starts and stops. It also catches System.out and System.err.

CATALINA_HOME/logs/tomcat.log

Look here for clues to all Tomcat issues. This is the main Tomcat log file.

/etc/httpd/logs/mod_jk.log

Look here for clues to mod_jk configuration issues.

12.2 Monitoring Connections

The following command can be used to monitor the Apache, Tomcat, and mod_jk connections:

 

netstat -vatn | grep 80

Below is output from running this command. Line numbers have been added to the beginning of each line for discussion purposes.

 

1 tcp        0      0 127.0.0.1:8005          0.0.0.0:*               LISTEN
2 tcp        0      0 127.0.0.1:8009          0.0.0.0:*               LISTEN
3 tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN
4 tcp        0      0 127.0.0.1:8009          127.0.0.1:34449         ESTABLISHED
5 tcp        0      0 127.0.0.1:34449         127.0.0.1:8009          ESTABLISHED

Notes

1. Line 1 shows Tomcat listening on port 8005 for the shutdown command.
2. Line 2 shows Tomcat listening on port 8009 for requests from Apache.
3. Line 3 shows Apache listening on port 80 for user requests.
4. Line 4 shows the Tomcat end of a mod_jk connection.
5. Line 5 shows the Apache end of a mod_jk connection.