Apache Tomcat :: Apache Software Foundation

Links

Reference Guide

Generic HowTo

Webserver HowTo

AJP Protocol Reference

Miscellaneous Documentation

News

The Apache Tomcat Connector - Reference Guide

uriworkermap.properties configuration

Printer Friendly Version
print-friendly
version
Introduction

The forwarding of requests from the web server to tomcat gets configured by defining mapping rules. Such a rule maps requests to workers. The request part of the map is described by a URI pattern, the worker by it's worker name.

The so-called uriworkermap file is a mechanism of defining rules, which works for all web servers. There exist also other web server specific configuration options for defining rules, which will be mostly discussed on the reference pages for configuring tomcat connectors for the individual web servers.

The name of the file is usually uriworkermap.properties, although this is configurable in the web server. Please consult the web server specific documentation pages on how to enable the uriworkermap file.

The main features supported by the uriworkermap file are

  • Support for comments in the rule file.
  • Exact and wildchar matches, shortcuts to map a directory and all including content.
  • Exclusion rules, disabling of rules and rule priorities.
  • Rule extensions, modifying worker behaviour per rule.
  • Virtual host integration: uri mapping rules can be expressed per virtual host. The details are web server specific though.
  • Dynamic reloading: The file gets checked periodically for changes. New versions are automatically reloaded without web server restarts.
  • Integration with the status worker.
The following sections describe these aspects in more detail.

Syntax

Line format

The file has a line based format. There are no continuation characters, so each rule needs to be defined on a single line. Each rule is a pair consisting of a URI pattern and a worker name, combined by an equals sign '=':

  /myapp=myworker
The URI pattern is case sensitive.

Comments, white space

All text after and including the character '#' gets ignored and can be used for comments. Leading and trailing white space gets trimmed around the URI pattern and also around the worker name. The following definitions are all equivalent:

  # This is a white space example
  /myapp=myworker
     /myapp=myworker
  /myapp  =  myworker

URI patterns

Inside the URI pattern three special characters can be used, '*', '?' and '|'. The character '*' is a wildchar that matches any number of arbitrary characters in the URI, '?' matches exactly one character. Each URI pattern has to start with the character '/', or with '*' or with '?', optionally prefixed by any combination of the modifiers '!' and '-' (see next section).

  # Mapping the URI /myapp1 and everything under /myapp1/:
  /myapp1=myworker-a
  /myapp1/*=myworker-a
  # Mapping all URI which end with a common suffix:
  *.jsp=myworker
  *.do=myworker
Since the first case of mapping a certain location and everything inside it is very common, the character '|' gives a handy shortcut:
  # Mapping the URI /myapp1 and everything under /myapp1/:
  /myapp1|/*=myworker-a
The pattern 'X|Y' is exactly equivalent to the two maps 'X' and 'XY'.

Exclusion, Disabling and Priorities

Exclusions and rule disabling

Exclusion rules allows to define exclusions from URI rules, which would forward requests to tomcat. If the exclusion rule matches, the request will not be forwarded. This is usually used to serve static content by the web server. A rule is an exclusion rule, if it is suffixed with '!':

  # Mapping the URI /myapp and everything under /myapp/:
  /myapp|/*=myworker
  # Exclude the subdirectory static:
  !/myapp/static|/*=myworker
  # Exclude some suffixes:
  !*.html=myworker
An exclusion rule overrides a normal mapping rule only, if the worker names in the normal rule and in the exclusion rule are the same. Starting with version 1.2.26 of JK you can apply an exclusion rule to any worker, by using the star character '*' as the worker name in the exclusion rule. More complex patterns in exclusion worker names are not allowed.
  # Mapping the webapps /myapp1 and /myapp2:
  /myapp1|/*=myworker1
  /myapp2|/*=myworker2
  # Exclude the all subdirectories static for all workers:
  !/*/static|/*=*
  # Exclude some suffixes for all workers:
  !*.html=*

Rule disabling comes into play, if your web server merges rules from various sources, and you want to disable any rule defined previously. Since the uriworkermap file gets reloaded dynamically, you can use this to temporarily disable request forwarding: A rule gets disabled, if it is suffixed with '-':

  # We are not in maintenance.
  # The maintenance rule got defined somewhere else.
  -/*=maintenance
Exclusion rules can get disabled as well, then the rule starts with '-!'.

Mapping priorities

The most restrictive URI pattern is applied first. More precisely the URI patterns are sorted by the number of '/' characters in the pattern (highest number first), and rules with equal numbers are sorted by their string length (longest first).

If both distinctions still do not suffice, then the defining source of the rule is considered. Rules defined in uriworkermap.properties come first, before rules defined by JkMount (Apache) and inside workers.properties using the mount attribute.

All disabled rules are ignored. Exclusion rules are applied after all normal rules have been applied.

There is no defined behaviour, for the following configuration conflict: using literally the same URI pattern in the same defining source but with different worker targets.

Rule extensions

Rule extensions were added in version 1.2.27 and are not available in earlier versions.

Syntax

Rule extensions are additional attributes, that can be attached to any rule. They are added at the end of the rule, each extension separated by a semicolon:

  # This is an extension example,
  # setting a reply_timeout of 1 minute
  # only for this mapping.
  /myapp=myworker;reply_timeout=60000
  #
  # This is an example using multiple extensions
  /myapp=myloadbalancer;reply_timeout=60000;stopped=member1
Attributes set via rule extensions always overwrite conflicting configurations in the worker definition file.

Extension reply_timeout

The extension reply_timeout sets a reply timeout for a single mapping rule.

  # Setting a reply_timeout of 1 minute
  # only for this mapping.
  /myapp=myworker;reply_timeout=60000
It overrides any reply_timeout defined for the worker. The extension allows to set a reasonable default reply timeout to the worker, and a more relaxed reply timeout to URLs, which are known to start time intensive tasks. For a general description of reply timeouts see the timeouts documentation.

Extension sticky_ignore

The extension sticky_ignore will disable session stickyness for a single mapping rule.

  # Disable session stickyness
  # only for this mapping.
  /myapp/loginform.jsp=myworker;sticky_ignore=1
This extension can be useful to optimize load balancing when using cookie based session stickyness. In this case, as long as she keeps her browser open, any request by a user who started a session will be send to the same Tomcat instance, even if he left the part of the application which uses the session. You can for instance set this environment variable when a user requests a login form to ensure, that this initial session request is balanced non-sticky.

This extension is available since version 1.2.33.

Extension stateless

The extension stateless is only useful when using session based load balancing. In this case normally any request which does not come with a session id counts as a new session. If you mark a mapping rule with the stateless extension, then the requests matching the mapping rule will not count as a new session, even if they do not come with a session id.

  # Don't let static content trash our session balancing
  /myapp/static/*=myworker;stateless=1
This extension is available since version 1.2.33.

Extensions active/disabled/stopped

The extensions active, disabled, and stopped can be used in a load balancer mapping rule to set selected members of the load balancer into a special activation state.

  # Stop forwarding only for member1 of loadbalancer
  /myapp=myloadbalancer;stopped=member1
Multiple members must be separated by commas or white space:
  # Stop forwarding for member01 and member02 of loadbalancer
  # Disable forwarding for member21 and member22 of loadbalancer
  /myapp=myloadbalancer;stopped=member01,member02;disabled=member21,member22
For the precise meaning of the activation states see the description of activation.

Extension fail_on_status

The extension fail_on_status can be used in any rule:

  # Send 503 instead of 404 and 500,
  # and if we get a 503 also set the worker to error
  /myapp=myworker;fail_on_status=-404,-500,503
Multiple status codes must be separated by commas. For the precise meaning of the attribute see the description of fail_on_status.

Extension use_server_errors

The extension use_server_errors allows to let the web server send an error page, instead of the backend (e.g. Tomcat) error page. This is useful, if one wants to send customized error pages, but those are not part of all web applications. They can then be put onto the web server.

The value of use_server_errors is a positive number. Any request send to the backend, that returns with an http status code bigger or equal to use_server_errors, will be answered to the client with the error page of the web server for this status code.

  # Use web server error page for all errors
  /myapp=myworker;use_server_errors=400
  # Use web server error page only for technical errors
  /myotherapp=myworker;use_server_errors=500

Extensions controlling load balancer stickyness

The extensions

  • session_cookie
  • session_path
  • set_session_cookie
  • session_cookie_path
allow to define the load balancer worker attributes of the same name per mount. See their descriptions in the worker.properties configuration reference.

Virtual host integration

IIS

When using IIS you can restrict individual rules to special virtual hosts by prefixing the URI pattern with the virtual host information. The rules is that the url must be prefixed with the host name.

  # Use www.foo.org as virtual host
  /www.foo.org/myapp/*=myworker
  # Use www.bar.org as virtual host
  /www.bar.org/myapp/*=myworker
  # Normal mapping
  /mysecondapp/*=myworker

Note that /mysecondapp/* will be mapped to all virtual hosts present. In case one needs to prevent the mappings to some particular virtual host then the exclusion rule must be used

  # Make sure the myapp is accessible by all virtual hosts
  /myapp/*=myworker
  # Disable mapping myapp for www.foo.org virtual host
  !/www.foo.org/myapp/*=myworker

Apache httpd

For Apache you can define individual uriworkermap files per virtual host. The directive JkMountFile can be used in the main server and in each virtual host. If a virtual host does not use JkMountfile, but JkMountCopy is set to 'On', then it inherits the JkMountFile from the main server. If you want all vhost to inherit mounts from the main server, you can set JkMountCopy to 'All' in the main server.

Dynamic reloading

When a request is being processed, tomcat connectors check the file modification time of the uriworkermap file. To keep the performance penalty low, this happens only, if the last check happened at least n seconds ago.

For Apache you can configure the interval "n" using the directive JkMountFileReload, for IIS you would use the attribute worker_mount_reload. The default value is 60 seconds. A value of "0" turns off the reloading.

If the file changed, it gets reloaded completely. If there exist rules coming from other sources than the uriworkermap file (e.g. the workers.properties mount attribute or JkMount with Apache httpd), the new uriworkermap file gets dynamically merged with these ones exactly like when you do a web server restart.

Until version 1.2.19 reloading behaved slightly differently: it continuously added the full contents of the uriworkermap file to the rule mapping. The merging rules were, that duplicated got eliminated and old rules could be disabled, by defining the rule as disabled in the new file. Rules never got deleted.

Status worker integration

The configuration view of the status worker also shows the various mapping rules. After each worker's configuration, the rules are listed, that forward to this worker. The list contains four columns:

  • the name of the virtual server
  • the URI pattern, prefixed with '-' for a disabled pattern and '!' for an exclusion pattern
  • the type of the rule: Exact or Wildchar
  • and the source of the rule definition: 'worker definition' for the workers.properties file (mount attribute), 'JkMount' for Apache httpd JkMount and it's relatives and finally 'uriworkermap' for the uriworkermap file.

Note: The following restriction has been removed starting with version 1.2.26.
For Apache httpd, there is an important subtlety: the request going to the status worker gets executed in the context of some server (main or virtual). The status worker will only show the mapping rules, that are defined for this server (main or virtual).
Until version 1.2.25 the list contained three columns:

  • the type of the rule: Exact or Wildchar, eventually prefixed with Disabled or Unmount (for exclusion rules)
  • the URI pattern
  • and the source of the rule definition: 'worker definition' for the workers.properties file (mount attribute), 'JkMount' for Apache httpd JkMount and it's relatives and finally 'uriworkermap' for the uriworkermap file.


Copyright © 1999-2014, Apache Software Foundation