|
|
|
|
Sponsored Link •
|
|
Advertisement
|
If we look at characteristics and the core values of RIFE and Terracotta, we can see many similarities:
Building the integration on this shared value proposition ensures that the use of Terracotta clustering will be almost completely transparent. RIFE users can enjoy the simplicity and power of continuation-based Web development, and still feel confident that they will meet their SLAs in terms of scalability and high-availability.
The rest of this article takes you through a simple RIFE application, and shows each step in clustering that application with Terracotta.
The easiest way to deploy the small sample application is to start from the RIFE/Jumpstart distribution that can be obtained from the project site (http://rifers.org/downloads). It contains a project structure recommendation that allows you to get started quickly, everything is setup for interactive development and painless deployment. The only requirement is to have a working JDK 1.5 installation.
After un-archiving the RIFE/Jumpstart zip file, we just need to drop in our two example files: (note: it's best to not have a space in the path in which you un-archive the jumpstart, since this confuses Ant)
Counter.java goes into the src
directorycounter.html goes into the
resources/templates directoryFinally, we edit the file resources/sites/pub.xml to tell
RIFE about the class name of this new element by adding the following
line inside the <site> tag:
<element implementation="Counter"/>
If everything goes well, you should be able to try this example out by typing the following lines in a console window (you need to have Ant installed for this, http://ant.apache.org):
$ cd rife-jumpstart-1.6.1 $ ant run
The example will be available at the URL
http://localhost:8080/counter, which you can visit in your
browser of choice. To stop the example, simply press the ctrl+c key
inside the console window.
To create a deployable war file, use the following Ant target:
$ ant war
You will find the created war file in the build/dist
directory, it can be used with any standard servlet container.
We have seen how to implement a conversational web application using RIFE and the concept of Web continuations. Let's now take a look at how we can enable high-availability and failover for our sample application by clustering it with Terracotta.
Sounds hard? Well, it actually turns out to be quite simple.
The RIFE integration is all wrapped inside a Terracotta Configuration Module. That means that the only thing you need to do in order to cluster RIFE is to write a Terracotta configuration file that looks something like this:
<tc:tc-config xmlns:tc="http://www.terracotta.org/config">
<!-- ...system and server stuff... -->
<clients>
<modules>
<module name="clustered-rife-1.6.0" version="1.0.0"/>
</modules>
<!-- ... other config ... -->
</client>
</tc:tc-config>
Put this snippet in an XML file named tc-config.xml
(actually, you can name it anything you like, but this is the naming
convention), and then feed it to the Terracotta runtime as explained in
the next section.
The only thing left that at this point is to enable the Terracotta runtime for our application. This is done by modifying the Tomcat application server's - or one of the other supported application servers, such as WebLogic, JBoss and Geronimo - startup script. Add the following environment variables at the top of the script:
set TC_INSTALL_DIR="<path to terracotta installation>" ("C:\Program Files\Terracotta\terracotta-<version>" by default)
set TC_CONFIG_PATH="localhost:9510"
call "%TC_INSTALL_DIR%\bin\dso-env.bat" -q
set JAVA_OPTS=%TC_JAVA_OPTS% %JAVA_OPTS%
In which:
TC_INSTALL_DIR environment variable is set to the
Terracotta installation root directory.TC_CONFIG_PATH is IP adress of the Terracotta server
that holds the tc-config.xml
Two useful tools that you should know about is dso-env
script, which helps you setup your environment to run a Terracotta
client application, using existing environment variables and setting
TC_JAVA_OPTS to a value you can pass to Java.
dso-env expects JAVA_HOME,
TC_INSTALL_DIR, and TC_CONFIG_PATH to be set
prior to invocation. It is meant to be executed via your custom startup
scripts, and is also used by each Terracotta demo script:
call "%TC_INSTALL_DIR%\bin\dso-env.bat" -q
Second one is make-boot-jar . It allows you to rebuild the
Terracotta boot jar for a JVM of your choice (if you switch JVM then you
always have to rebuild the boot jar).
%TC_INSTALL_DIR%\bin\make-boot-jar.bat -o %TC_INSTALL_DIR%\lib\dso-boot\
If you want to easily play with what you learned in this article, you can use the Terracotta 2.4 distribution which contains useful examples that are set up for running on your own workstation. The architecture is basically a Terracotta server and a simple round-robin load balancer that distributes the load to three Tomcat servers that run on their own dedicated ports.
The Terracotta 2.4 distribution already contains a RIFE sample setup in
the %TC_INSTALL_DIR%\samples\rife\continuations directory.
You can replace the target\continuations.war file with the
one you generated through RIFE/Jumpstart. Just make sure you preserve
the continuations.war name , since the Tomcat
configurations expect that file name.
You now only need to adapt the tc-config.xml file in the
sample directory to include the element class you wrote:
<tc:tc-config xmlns:tc="http://www.terracotta.org/config">
<!-- ...system, server and clients stuff... -->
<application>
<dso>
<instrumented-classes>
<include>
<class-expression>Counter</class-expression>
</include>
</instrumented-classes>
</dso>
</application>
</tc:tc-config>
Starting the demo is simply a matter of double-clicking on each one of these:
%TC_INSTALL_DIR%\samples\start-demo-server.bat
%TC_INSTALL_DIR%\samples\rife\continuations\start-load-balancer.bat
%TC_INSTALL_DIR%\samples\rife\continuations\start-tomcat1.bat
%TC_INSTALL_DIR%\samples\rife\continuations\start-tomcat2.bat
%TC_INSTALL_DIR%\samples\rife\continuations\start-tomcat3.bat
Now you can visit the application at the URL
http://localhost:8080/continuations/counter (the war file is deployed at
the continuations path):
When you click the application a number of times, it's worthwhile to
launch the Terracotta administration console by double-clicking on
%TC_INSTALL_DIR%\bin\admin.bat and connecting to the
server with the default parameters. You can for example browse through
the active continuations and inspect their state, look at the server
statistics and much more:
That's all there's to it. We hope that you have gained an understanding
of what RIFE and Terracotta can do for you and how you can use them
seamlessly together to create a solid application stack that allows you
to scale. With this combination, you can scale out and ensure
high-availability for your applications without sacrificing simplicity
and productivity. That means working with true POJOs with minimal
boilerplate and infrastructure code.
Discuss this article in the Articles Forum topic,
Distributed
Web Continuations with RIFE and Terracotta.
Resources
Terracotta - Scalable High-Availability for Java http://terracotta.org
RIFE - Full-stack component framework for quickly building maintainable applications http://rifers.org
The Java Memory Model http://java.sun.com/docs/books/jls/third_edition/html/memory.html
Overview of the Terracotta Architecture http://www.terracotta.org/confluence/display/docs1/Terracotta+Scalability#TerracottaScalability-THEARCHITECTURE
Description of "locality of reference" from Wikipedia http://en.wikipedia.org/wiki/Locality_of_reference
Fine-grained Updates in Terracotta http://www.terracotta.org/confluence/display/docs1/Terracotta+Scalability#TerracottaScalability-FINEGRAINEDUPDATES
Jonas Bonér is working at Terracotta Inc. with a focus on strategy, product development & architecture and technical evangelism. He is the founder of the AspectWerkz AOP framework, has been a committer to the Eclipse AspectJ 5 project and various other open source projects. He is a frequent speaker on AOP, JVM-level clustering and other emerging technologies. For more info, see his blog: http://jonasboner.com
Geert Bevin is a senior developer and advocate at Terracotta Inc.. He is the CEO and founder of Uwyn bvba/sprl, and created the RIFE project. He started or contributed to open-source projects like Bla-bla List, OpenLaszlo, Drone, JavaPaste and Gentoo Linux. Geert is also an official Sun Java Champion.
|
Sponsored Links
|