1. When you build Apache from source add these flags:

--enable-proxy-ajp --enable-proxy-balancer --enable-proxy

2. Set up your cluster by doing this:

<Proxy balancer://tomcat_cluster>
BalancerMember ajp://192.168.1.1:8009
BalancerMember ajp://192.168.1.2:8009
BalancerMember ajp://192.168.1.3:8009
</Proxy>

3. Then, add the Rewrite rule that will Proxy the request to your cluster.

RewriteEngine On
RewriteRule ^/(.*)$ balancer://tomcat_cluster%{REQUEST_URI}
[P,QSA,L]

1. Add the the status_module to your apache configuration.

2. Then configure a virtualhost for server-status only access, edit x as follows:

<VirtualHost 127.0.0.1:80>
<Location /server-status>
SetHandler server-status
Order Deny,Allow
Deny from all
Allow from localhost
Allow from 127.0.0.1
</Location>
</VirtualHost>

Now you can access the Apache status screen using this url http://127.0.0.1/server-status ONLY from localhost.

1. Stop the server.

2. Rename the old log file (date.logfile or logfile.1, for example).

3. Compress the archived log.

4. Restart the server.

The current running log file will have the same name as the original so it should not be necessary to change your monitoring routines.

We typically recommend using a general purpose utility like logrotate (which is actually a shell script) rather than a custom script, as this centralizes all the log file rotation on the server to a common set of configuration files. This way you can leverage the support of the logrotate community as well as other system administrators.

This vulnerability potentially allows the unauthorized modification of HTTP requests by allowing remote attackers to corrupt the Web cache and bypass Web application firewall protection. This could allow cross site scripting attacks via HTTP requests with both a “Transfer-Encoding” and “Content-Length” header. In a practice known as “HTTP Request Smuggling,” Tomcat will then incorrectly handle and forward the body of the request when transmitting it to the receiving server, leading it to be processed as a separate HTTP request.

Given that this vulnerability allows unauthorized modification of requests, it has been classified as a LOW risk.

First identify the Tomcat process ID and then run “kill -9 [process id]” (where [process id] is replaced with the process id, including the square brackets). This triggers a thread dump. You can then use the thread dump to identify which thread is hanging. Fix the relevant code, or ignore the state of the JVM.

Fortunately, the Tomcat team has put together 64 bit versions of these executables, although they only include them in the source distribution for each version of Tomcat. If you’ve already installed a copy of Tomcat, here’s how to update the executables:

1. Download and extract the source distribution for your version of Tomcat from OLEX
2. Find the directory tomcat-X.X.XX-src/connectors/procrun/bin/amd64/
3. Copy the executables from the above directory into the tomcat-X.X.XX/bin, overwriting the 32 bit versions
4. Run the command service.bat install. This will install the service under the displayed name Apache Tomcat (the service name will be Tomcat5).

For a patch to MulticastDiscoveryAgent, navigate to the ActiveMQ site. You can also read more about this issue on the ActiveMQ site.

If you are unable to move to a newer version, the code can be patched using code from the 3.2.6 release. Several patches are needed to update your instance of 3.2.5 code to function like version 3.2.6 code.

The following links provide access to the relevant code fixes necessary to resolve this issue.

• Generated Lazy statement leak http://opensource.atlassian.com/projects/hibernate/secure/attachment/13263/generated-lazy-statement-leak.patch
• preparedSelectStatement fix http://opensource.atlassian.com/projects/hibernate/secure/attachment/13323/HHH-2627-AbstractBatcher_prepareSelectStatement.patch
• SharedPKOnetoOne fix http://opensource.atlassian.com/projects/hibernate/secure/attachment/13296/HHH-2627-SharedPKOneToOne.patch
• Test case to verify the issue http://opensource.atlassian.com/projects/hibernate/secure/attachment/13295/HHH-2627-testcase.patchAnswer

So, when you define a composite-id element of the “someclass” class as follows

<COMPOSITE-ID>
<KEY-PROPERTY name="column1" column="column1">
<KEY-PROPERTY name="column2" column="column2">
<KEY-PROPERTY name="column3" column="column3">
<KEY-PROPERTY name="column4" column="column4">
<KEY-PROPERTY name="column5" column="column5">
<COMPOSITE-ID>

what you are saying is that a ’someclass’ object is always and forever uniquely identified by examining the contents of the following columns: column1, column2, column3, column4, column5. In other words, if all the values of those 5 columns appended together turns out to be ‘ABCDE’ (column1 = ‘A’, column2 = ‘B’ and so on), we ought not to have another row in that table in the database that would result in ‘ABCDE’ if appended together.

Since you’ve defined the composite-id for the ’someclass’ object in this way, Hibernate expects any other class that maps to this one (in other words, creates an association of some kind) to declare those exact same columns in its mapping. Here are two examples:

A “many-to-one” example:

<many-to-one name="many_name">
  <column name="column1" />
  <column name="column2" />
  <column name="column3" />
  <column name="column5" />
</many-to-one>

A “collection” example:

<set name="collection_name" inverse="true">
  <key>
    <column name="column1" />
    <column name="column2" />
    <column name="column3" />
    <column name="column4" />
    <column name="column5" />
  </key>
  <one-to-many class="someclass" />
</set>

The Hibernate documentation warns that you ‘must override equals() and hashCode() to implement composite identifier equality. It must also implement Serializable.’

Trying to define multiple composite-id’s for the same object simply doesn’t work, in that it would be akin to defining the ‘equals()’ method in two completely separate and distinct ways for one class, which is not even possible.

Once you define a composite-id for a particular class, the exact columns used in this definition must be those used when mapping other objects to the original object you defined the composite-id.