tomcat-users mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Shay Rojansky <>
Subject Re: "Application" vars -
Date Sat, 03 Jul 2010 04:34:09 GMT
Just my comments on the dispatching idea proposed below...

If smooth processing with no freeze-time is important, I'm assuming there is
also some sort of cluster/high-availability functionality. If this is the
case, you are already running at least two Tomcats on different servers, and
using some load-balancing/dispatch mechanism - for example Apache with
mod_jk. If you have just one Tomcat you have much more to worry about than
Tomcat freezing during webapp reload :)

So, why not just use the load balancer's functionalities, instead of writing
a dispatcher yourself (webappX below)? In other words, you stop the webapp
on tomcat1 - the load balancer (or mod_jk or whatever) detects this
immediately and stops forwarding requests to it. You do whatever config
change, and start the app again. At this point the new app is added back to
the load balancer. Repeat same thing with tomcat2, tomcat3...

Seems simpler than deploying two copies of a webapp + a third dispatcher
that you need to write and maintain (and all this across the N servers in
your cluster)...

One last note: if I remember correctly, you can only forward requests within
the same servlet context (i.e. webapp), so "dispatching" from webappX to
webappA or webappB would be non-trivial. You could do redirections, but this
exposes your internal mechanism to clients and is really bad.


On Fri, Jul 2, 2010 at 4:27 AM, André Warnier <> wrote:

> Eric P wrote:
>> So it makes sense to go into what "disruption" means. I'm not 100% sure
>>> about the following, it would be good if a tomcat heavyweight would
>>> confirm/refute what I say.
>>> When you initiate a webapp reload, Tomcat waits for requests that have
>>> already started processing to terminate. This ensures that people who
>>> accessed your app just before the webapp get a complete response. Once
>>> that's done, the application is reloaded and your servlets' init methods
>>> are
>>> called if necessary. During this time, incoming requests aren't denied,
>>> they
>>> are just paused until the reload is complete.
>>> So the only disruption people see is your application freezing up for the
>>> time it takes to reload (which is going to depend on what you your
>>> initialization consists of). No ugly server unavailable errors or
>>> anything
>>> of the sort.
>>> If you don't like the idea of your app freezing, think about this.
>>> Rereading
>>> environment params without reloading has its own risks, namely potential
>>> race conditions. Imagine you have 5 parameters, and requests are coming
>>> in
>>> as you are reading these in and initializing your webapp. A request might
>>> be
>>> handled while 2 params have been read, but 3 still contain the old
>>> values.
>>> If you start to think about locking/synchronization to solve this you're
>>> definitely better off just using Tomcat's reload mechanism.
>>> So my answer would be, trust Tomcat's reloading process unless you
>>> absolutely want to avoid your webapp freezing for the time it will take
>>> for
>>> it to init (this depends on the webapp). If you want to do your own
>>> "reloading", think long and hard about potential race conditions (which
>>> will
>>> occur in all except the simplest cases).
>>> Again, all this should probably be verified, you can set up very simple
>>> test
>>> cases with a JSP that  sleeps, etc.
>> Shay,
>> I think you made a good case for keeping app vars in web.xml (i.e., seems
>> pretty apparent now that's where they belong).
>> Thanks for taking the time to respond.  I sincerely appreciate it!
>> Eric P.
>>  +1
> Very neat explanation.
> While not being a great specialist, I would just like to expone what may be
> an alternative, if one really wants to diminish the (apparent) time it takes
> for a new version of a webapp to become available.  Since I am no great
> specialist, I will just outline the idea without Java/servlet specifics.
> (Maybe also I am barging through an open door, and there already exists a
> standard mechanism for doing this, but oh well..)
> Imagine that you have 2 identical versions of the same intrinsic webapp
> deployed, like
> catalina_base/webapps/webappA
> catalina_base/webapps/webappB
> You create a 3rd webapp webappX, which is the one the users see, and which
> is just a "dispatcher" to either one of the two webapps webappA and webappB.
> So you now have :
> catalina_base/webapps/webappX
> catalina_base/webapps/webappA
> catalina_base/webapps/webappB
> The users always use the URL "/webappX".
> When a call is made to webappX, /it/ decides, in function of some external
> parameter Y, whether to dispatch the call to either webappA or webappB.
> Say that initially the external parameter Y (which could be a system-wide
> property) is set so that all calls to "/webappX" are currently dispatched to
> /webappA.
> Now you want to update webappA.
> You change the parameter Y so that calls are now dispatched to (identical)
> /webappB.
> Then you update (redeploy) webappA.  Users see no delay, because they get
> directed to webappB.
> When webappA is deployed and started (which you could check by calling it
> directly),
> you can reset the parameter Y to its former value, and users will again be
> dispatched to webappA.  Now you can redeploy webappB, to keep it in sync.
> ---------------------------------------------------------------------
> To unsubscribe, e-mail:
> For additional commands, e-mail:

  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message