We’ve got a Java server application that runs on a number of computers, all connected to the Internet, some behind firewalls. We need to remotely update the JAR files and startup scripts from a central site, with no noticeable interruption to the app itself.
The process has to be unattended and foolproof (i.e. we can’t afford to break the app due to untimely internet outages).
In the past we’ve used a variety of external scripts and utilities to handle similar tasks, but because they have their own dependencies, the result is harder to maintain and less portable. Before making something new, I want to get some input from the community.
Has anyone found a good solution for this already? Got any ideas or suggestions?
Just to clarify: This app is a server, but not for web applications (no webapp containers or WAR files here). It’s just an autonomous Java program.
You didn’t specify the type of server apps – I’m going to assume that you aren’t running web apps (as deploying a WAR already does what you are talking about, and you very rarely need a web app to do pull type updates. If you are talking about a web app, the following discussion can still apply – you’ll just implement the update check and ping-pong for the WAR file instead of individual files).
You may want to take a look at jnlp – WebStart is based on this (this is a client application deployment technology), but I’m pretty sure that it could be tailored to performing updates for a server type app. Regardless, jnlp does a pretty good job of providing descriptors that can be used for downloading required versions of required JARs…
Some general thoughts on this (we have several apps in the same bucket, and are considering an auto-update mechanism):
Consider having a bootstrap.jar file that is capable of reading a jnlp file and downloading required/updated jars prior to launching the application.
JAR files can be updated even while an app is running (at least on Windows, and that is the OS most likely to hold locks on running files). You can run into problems if you are using custom class loaders, or you have a bunch of JARs that might be loaded or unloaded at any time, but if you create mechanisms to prevent this, then overwriting JARs then re-launching the app should be sufficient for update.
Even though it is possible to overwrite JARs, you might want to consider a ping-pong approach for your lib path (if you don’t already have your app launcher configured to auto-read all jar files in the lib folder and add them to the class path automatically, then that’s something you really do want to do). Here’s how ping-pong works:
App launches and looks at lib-ping\version.properties and lib-pong\version.properties and determines which is newer. Let’s say that lib-ping has a later version. The launcher searches for lib-ping*.jar and adds those files to the CP during the launch. When you do an update, you download jar files into lib-pong (or copy jar files from lib-ping if you want to save bandwidth and the JAR didn’t actually change – this is rarely worth the effort, though!). Once you have all JARs copied into lib-pong, the very last thing you do is create the version.properties file (that way an interrupted update that results in a partial lib folder can be detected and purged). Finally, you re-launch the app, and bootstrap picks up that lib-pong is the desired classpath.
ping-pong as described above allows for a roll-back. If you design it properly, you can have one piece of your app that you test the heck out of and then never change that checks to see if it should roll-back a given version. That way if you do mess up and deploy something that breaks the app, you can invalidate the version. This part of the application just has to delete the version.properties file from the bad lib-* folder, then re-launch. It’s important to keep this part dirt simple because it’s your fail safe.
You can have more than 2 folders (instead of ping/pong, just have lib-yyyymmdd and purge all but the newest 5, for example). This allows for more advanced (but more complicated!) rollback of JARs.