The Apache Tomcat Connectors - Web Server HowTo

${tomcat_home} is the root directory of tomcat. Your Tomcat installation should have the following subdirectories:

• ${tomcat_home}\conf - Where you can place various configuration files
• ${tomcat_home}\webapps - Containing example applications
• ${tomcat_home}\bin - Where you place web server plugins

In all the examples in this document ${tomcat_home} will be c:\tomcat. A worker is defined to be a tomcat process that accepts work from the iPlanet Web Server.

The NSAPI redirector was developed and tested on:

• WINNT 2000/XP/2003 (should be able to work with other service packs) and some Unixes
• Sun ONE Web Server 6.1
• Tomcat 4.1 to Tomcat 8.

The redirector uses the AJP protocol to send requests to the Tomcat containers. The AJP version typically used is ajp13.

Tomcat supports ajp13 since Tomcat 3.2. Others servlet engines such as Jetty or JBoss also support the ajp13 protocol

The ajp12 protocol has been deprecated and you should no longer use it. The ajp14 protocol is considered experimental.

1. The NSAPI redirector is a web server plugin based on the NSAPI web server API. The web server loads the NSAPI redirector plugin and calls its service handler function for all requests that are assigned to the "servlet" configuration object.
2. For each in-coming request the web server will execute the set of NameTrans directives that we added to obj.conf, the assign-name function will check if it's from parameter matches the request URL.
3. If a match is found, assign-name will assign the servlet object name to the request. This will cause the web server to send the request to the servlet configuration object.
4. The web server will execute our jk_service extension. The extension collects the request parameters and forwards them to the appropriate worker using the ajp13 protocol (the worker="defworker" parameter in jk_service inform it that the worker for this request is named defworker). the workers properties files, workers.properties, will indicate that defworker use ajp13 protocol.
5. The extension collects the response from the worker and returns it to the browser.

The examples context is useful for verifying your installation, but you will also need to add your own contexts. Adding a new context requires two operations:

• Adding the context to Tomcat (I am not going to talk about this).
• Assigning the NSAPI redirector to handle this context.

Assigning the NSAPI redirector to handle this context is simple, all you need to do is to edit obj.conf and add a NameTrans line that looks like:

NameTrans fn="assign-name" from="/<context_name>/*" name="jknsapi"

After saving obj.conf restart the web server and it will serve the new context.

Sometimes it is better to have the web server serve the static pages (html, gif, jpeg etc.) even if these files are part of a context served by Tomcat. For example, consider the html and gif files in the examples context, there is no need to serve them from the Tomcat process. The web server can do it on its own.

Making the web server serve static files that are part of the Tomcat contexts requires the following:

• Configuring the web server to know about the Tomcat contexts
• Make sure that the WEB-INF and META-INF directories are protected from access.
• Configuring the web server to assign the NSAPI redirector only specific requests that requires JSP/Servlet handling.

Adding the contents of a Tomcat context to the web server requires the addition of a new virtual directory that covers the Tomcat context.

For example, adding a /example virtual directory that covers the c:\tomcat\webapps\examples directory.

To add a new virtual directory add the following line to your obj.conf:

NameTrans fn=pfx2dir from=/examples dir="c:/tomcat/webapps/examples"

WEB-INF protection requires some explanation; Each servlet application (context) has a special directory named WEB-INF, this directory contains sensitive configurations data and Java classes and must be kept hidden from web users. A second directory that should be protected is META-INF. Those directories can be protected by adding the following line to the PathCheck section in the default configuration object:

PathCheck fn="deny-existence" path="*/WEB-INF/*"
PathCheck fn="deny-existence" path="*/META-INF/*"

Configuring the web server to assign the NSAPI redirector only specific requests is somewhat harder, you will need to specify the exact URL-Path pattern(s) that you want Tomcat to handle (usually only JSP files and servlets).

This requires a change to NameTrans portion of obj.conf.

For the examples context it requires to replace the following line:
  
NameTrans fn="assign-name" from="/examples/*" name="jknsapi"
  
with the following two lines:
  
NameTrans fn="assign-name" from="/examples/jsp/*.jsp" name="jknsapi"
NameTrans fn="assign-name" from="/examples/servlet/*" name="jknsapi"

As you can see the second configuration is more explicit, it actually instructs the web server to assign the redirector with only requests to resources under /examples/servlet/ and resources under /examples/ whose name ends with .jsp.

You can be even more explicit and provide lines such as:

NameTrans fn="assign-name" from="/examples/servlets/chat" name="jknsapi"
  
Instructs the web server to assign the redirector requests whose URL path equals /example/servlets/chat

Sometimes you want to serve different contexts with different Tomcat processes (for example to spread the load among different machines). To achieve such goal you will need to define several workers and assign each context with its own worker.

Defining workers is done in workers.properties, this file includes two types of entries:

#An entry that lists all the workers defined. For example:
worker.list=worker1,worker2
  
# Entries that define the host and port associated with these workers.
worker.worker1.host=localhost
worker.worker1.port=8009
worker.worker1.type=ajp13

worker.worker2.host=otherhost
worker.worker2.port=8009
worker.worker2.type=ajp13

The above examples defined two workers, now we can use these workers to serve two different contexts each with it's own worker. Submitting requests to different workers is accomplished by using multiple Service directives in the servlet configuration Object, each with a different path pattern parameter.

For example, if we want to submit the /examples context to the worker named worker1 and the /webpages context to the worker named worker2 we should use the following configuration:

<Object name="jknsapi">
ObjectType fn=force-type type=text/plain
Service fn="jk_service" worker="worker1" path="/examples/*"
Service fn="jk_service" worker="worker2" path="/webpages/*"
Service fn="jk_service" worker="worker1"
</Object>

More informations on using and configuring workers in the Workers HowTo and in the worker.properties configuration reference.