Resin 4.0.36

2013-04-25

Description

ProxyCache

Resin's HTTP Proxy module has been updated to support full load-balancing, failover, and network timeouts. A proxycache cluster was added to resin.xml and resin.properties, including the new 'backend_servers' property used to supply a list of backend HTTP servers to proxy to. Resin's proxy-cache request caching capability is automatically applied on this layer, providing true HTTP caching proxy capability.

BAM: clustered messaging

The low-level queuing implementation for BAM's mailboxes has been updated to better handle high load spikes. The BAM queues have also been extended to handle larger load.

Resin 4.0.34

2013-01-30

Description

Gzip Filter Fix

A GZipFilter bug introduced in 4.0.33 was causing slow or incomplete page loading. Users utilizing GZipFilter should upgrade to 4.0.34.

OpenSSL honor-cipher-order

The new SSL configuration matches the Apache HTTPD configuration. It enforces the cipher order specified by the server, overriding the client's preferences.

<jvm-mode> and Early Raspberry Pi Support

<jmv-mode> parameter was introduced to change the JVM mode, to allow alternatives to -server. This change and other bug fixes allows Resin to run on the Raspberry Pi platform.

Quercus PHP 5.4 support

Quercus now supports the core PHP 5.4 language features.

ServletRegistration and servlet-mapping default

Added a "default" attribute to Resin's default servlet-mapping and changed the ServletRegistration behavior to override servlet-mapping defaults. The standard behavior of ServletContext.addServlet is to ignore overrides of servlet mappings. The new "default" attribute lets applications override the Resin defaults.

Resin 4.0.31

2012-09-12

Description

dynamic server for Amazon EC2

Resin App Server elastic deployments on EC2 have been simplified and improved. You can start a new Resin App Server instance, by launching a new instance from a saved image. Because of Resin's "Deploy Once" model, the deployed application will appear on the new server automatically.

Resin 4.0.30

2012-08-20

Description

CLI: dynamic server clarification

Dynamic servers are started on the command line with an "--elastic-server" flag. The "--elastic-server" flag lets you configure dynamic servers on the same machine as your triad servers.

CLI: --elastic-dns for cloud environments

For cloud environments where a dynamic IP address is assigned and bound to a DNS value, Resin can start immediately with the --elastic-dns flag, and continue checking the addresses until one resolves to a local IP address.

Performance and Scalability

Resin 4.0.30 outperforms nginx 1.2 as a webserver. In our benchmarks, Resin is able to serve 100,000 requests per second.

port-max thread throttling

The maximum number of active threads for a port can be restricted with
port-max thread throttling (port_thread_max in the resin.properties).

The number of requests can be much larger, because async keepalives and
comet/async threads and inactive websocket connections, are not counted as
active threads. The throttling can improve performance by reducing thread
contention.

resin.properties: port_thread_max

# throttle the number of active threads for a port
port_thread_max : 256

http_ping_urls for watchdog reliability checks

The resin.properties now has a http_ping_urls for improved reliability.
You can add a list of URLs to be checked periodically to ensure the site
is responding properly at all times. If the HTTP response fails, the watchdog will restart Resin automatically, after retrying.

resin.properties

http_ping_urls : http://my.example.org/test_page.jsp

Ping Time meters and anomaly detection

The HTTP Ping Time is metered and checked as part of the health system.
The PDF report and the /resin-admin meters will show the ping time. An
anomaly analyzer is attached to the Ping Time, to detect if the response
time cchanges.

WebSocket messaging model improvements

Since WebSockets is a messaging protocol, it's best to program using
a messaging model, sending messages to queues to be sent to the client.
Following this model, we've changed the WebSockets API to allow for
custom marshalling and queue handling to the stream.

Static File Performance

Resin's static file serving is now faster and more efficient with
the operating system sendfile() support. Large files are sent directly
from the file system to the HTTP socket by the operating system, minimizing
Java overhead.

.deb package distribution

Default resin user and group is changed to www-data for Resin Daemon.

REST Administration Interface

New Resin REST interface provides an http(s) integration point. By default
the interface is disabled. To enable the interface edit resin.properties to
set rest_admin_enable property to true. Also configure admin_user and
admin_password.

Once the three prerequisites are met rest interface is available at its
default url: http://locahost:8080/resin-rest

Resin 4.0.25

2012-01-24

Description

Summary

Thanks to everyone who reported bugs in 4.0.24. We encourage people to
report 4.0.25 bugs at
http://bugs.caucho.com.

4.0.25 includes an update of the WebSocket support for the final
RFC 6455 release.

It includes several changes to improve the cloud support to make
Resin PAAS ready without needing additional PAAS-provider support.
The specific changes include dynamic server updates
and cloud configuration.

PDF

Snapshot and Watchdog PDF reports have been reformed and updated to
include more information including Resin paths, ports, licenses, and
health status.

PDF reports can be generated on-demand from the Summary
and Watchdog pages in resin-admin, automatically in health.xml,
or from the command line as follows:

CLI: added $HOME/.resin and --mode

The command-line resinctl will now look in $HOME/.resin
for properties to launch the watchdog with. The --mode option selects
groups of properties.

The purpose of the $HOME/.resin is to allow remote CLI
administration of Resin (by setting the server addresses) without
needing to change the /etc/resin.properties.

Config: /etc/resin/resin-inf

Local configuration and jars can now be placed in /etc/resin/resin-inf
without needing to change the resin.xml itself. A jar placed in /etc/resin/resin-inf/lib/mysql.jar will be available to the entire server.

Config: EL/rvar merging

EL variables in the resin.xml will now lookup properties without
needing the "rvar" function. For a server id "app-0", ${http} will
look for "app-0.http" in the resin.properties and if that's missing,
use "http".

Config: sample resin.xml updated

The sample resin.xml has been updated and split into a
sample "cluster-default.xml" to better show the base configuration.

Config: cloud configuration

Cloud configuration support has been added to Resin. When a new
Resin server spins up, it will ask the triad hub for the cloud
configuration updates, which will include any shared database drivers
and configuration.

The cloud configuration is structured like the /etc/resin
directory, and is imported by the resin.xml. (You can look at
/etc/resin/resin.xml to see how this is done.)

The command-line "config-deploy" will deploy the cloud configuration.
"config-ls" and "config-cat" will show the configuration for debugging.

The configuration can be bundled into a .jar or deployed as a directory
with the "config-deploy"

resinctl config-deploy with directory

unix> resinctl config-deploy my-cloud-conf

resinctl config-deploy with jar

unix> resinctl config-deploy my-cloud-conf.jar

When the configuration is deployed, it is parsed just like any
other resin configuration file or jar file.

Cloud: dynamic servers and home-cluster

When your configuration has more than the three servers
in the triad hub, you can use the <home-cluster> configuration
to automatically configure the additional spoke servers.
The <home-cluster> tells Resin which cluster your new server
should belong to. When you start the new server, it will contact
the triad hub and connect itself, becoming a new cloud server.

Once the cloud server is connected, it will download any
cloud configuration changes like a new database driver, and any
application deployments.

resin.properties

The configuration for common deployments has been simplified,
moving the most often changed values into a separate
resin.properties file. While Resin's resin.xml is still the basis for the
configuration, it now includes the resin.properties
with a <resin:properties> tag.

The variables are all defined and controlled by
the /etc/resin/resin.xml file. If you are already modifying the resin.xml,
you can use this technique for your own properties.

resin:properties

Resin has a new <resin:properties> tag that works similarly to
the <resin:import>, but populates the EL configuration variables.
You can use this to implement /etc/resin/resin.properties and you
can use it in systems like Amazon EC2 where per-instance user-data
is available via an http URL.

rvar(): EL config function for properties

The new "rvar()" function in the resin.xml is used with resin.properties
to allow server-specific configuration to override general configuration.
For example, "http : 8080" defines the default HTTP port as port 8080,
and "app-0.http : 8081" sets the HTTP port to 8081 when the server
is named "app-0".

resin.xml Local Config files: /etc/resin/local.d/*.xml

Resin's default /etc/resin/resin.xml now imports files from
/etc/resin/local.d/*.xml as local additions to the resin configuration.
It uses an existing capability of the <resin:import> to include
a fileset of paths.

The standard health.xml configuration has been moved to local.d.

The local.d can be used for simple configuration extensions, like adding
a cluster-wide mysql configuration, or importing EC2/cloud properties
file as in the above example. The top-level tag for the *.xml will
be <resin> because the <resin:import> occurs at the <resin>
level.

server-multi: allowing cluster definition in resin.properties

The new <server-multi> tag is designed to work with the
resin.properties file to allow multiple servers to be defined
with a single property. The address-list attribute allows a
space delimited list of addresses. The server-multi will expand into
multiple <server> tags, one for each address.

For example, you can use this system to configure
the triad in the resin.properties without needing to modify the
resin.xml file.

The following example defines three servers named "app-0", "app-1",
and "app-2" which are configured for internal IP addresses
192.168.1.10, 192.168.1.11, and 192.168.1.12. The ":6801" overrides
the default server port.

join-cluster: allowing dynamic servers resin.properties

The <join-cluster> tag in the resin.xml informs the watchdog
which cluster the server instance should join. It is equivalent to
the -join-cluster command line argument. The join-cluster tag allows
dynamic servers to work with the same /etc/resin.d/resin, and allows
EC2-cloud servers to be configured with just the cloud /user-data
configuration.

resinctl and bin/resin.sh

A new command-line script "resinctl" has been added as an alternative
to bin/resin.sh. "resinctl" differs from bin/resin.sh by including
the OS paths in the script itself. In other words, on a linux system,
resinctl knows that the default resin.xml is in /etc/resin and the default
root-directory is /var/www.

With the .rpm and .deb, resinctl is now installed in /usr/bin/resinctl,
which makes it easily available from the command-line.

CLI: license-add

resinctl now has a "license-add" command which copies a license to
the license directory, as a convenience.

Example: uploading a license

unix> resinctl license-add 1013009.license

CLI: start-all

The resinctl start-all command starts all servers on the local host by
looking at the IP interfaces and matching them with the <server>
and <server-multi> definitions. The start-all lets
the /etc/init.d/resin start all servers without needing to be modified.

Unix startup: /etc/init.d/resin

The /etc/init.d/resin script has been changed so fewer sites
will need to modify it.
Since it also uses "start-all" to start all <server> configurations
on the current machine, it no longer needs a -server configuration.
The script now calls /usr/bin/resinctl to start
and stop Resin.

memcache client/server

Resin's cache now supports a memcache interface for both the client
and the server. When Resin is used as both the client and
the server, adding and removing cache servers are automatically rescaled
and updated in the client.

The client API for Resin's memcache is jcache (javax.cache). The
configured cache can be injected like any CDI object.

Health: AnomalyAnalysis

The health check system has some early anomaly analysis. The analyzer will
look at a meter value, checking for deviations from the average value.
So unusual changes like a spike in blocked threads can be detected.

Health: Watchdog and Postmortem

The Postmortem report has been renamed to be the
watchdog restart report, primarily for translation purposes. We're now
describing the watchdog as the entire check/restart/report system, where the
watchdog process is only a part.

Command Line Interface

The "stop" and "kill" commands can be used without the -server option if
the current watchdog has a single server active.

WebSocket

The WebSocket implementation has been upgraded to draft 16.

jCache and Performance

The jCache API has been upgraded (although that's a moving target.)
Performance has been improved, particularly for caches with a low locality
rate. The user key to internal hash key cache has been merged into the
global manager and its size increased.

Experimental testing of Resin's cache used as a memcache server shows
comparable performance with memcached on certain loads.

WebSocket

Messages are read in an application callback implementing
WebSocketListener. The listener reads the InputStream until end of file
which is the end of message, and then returns to allow the next message
to be read.

Custom Graph Pages

The graphs in the /resin-admin "meters" section can be configured
by adding <health:MeterGraphPage> definitions to the health.xml or the
resin.xml. The graph values are defined by <health:JmxMeter> and
<health:JmxMeter> and allow any JMX value to be metered and displayed.

Resin 4.0.19

2011-06-14

Description

Summary

4.0.19 is primarily a bug fix release, including several
important fixes in the networking code for timeouts.

Thanks to everyone who reported bugs in 4.0.18. We encourage people to
report 4.0.19 bugs at
http://bugs.caucho.com.

Resin Eclipse Plugin

Resin Eclipse Plugin is updated to publish and reload applications instantly.
These settings can be overridden in the Properties dialog (press F3 on the selected server).
Fixed bugs: http://bugs.caucho.com/view.php?id=4589.

The new actions and predicates can be combined to initiate an intelligent diagnostic gathering
restart sequence. In the following example, upon detecting a critical health condition, Resin
registers a 10 minute delayed fail-safe restart, dumps diagnostic information, and then profiles
the system for 5 minutes. Finally it attempts to restart cleanly, although if that is not
possible due to system instability, the earlier fail-safe restart will trigger.

Resin 4.0.18

2011-05-12

Description

Summary

4.0.18 is primarily a bug fix release.

(CLI) Resin command line updates

Resin 4.0.18 introduces commands to manage jmx objects. New set of JMX
Commands consists of jmx-list, jmx-set and jmx-call commands.
Documentation
for an updated CLI interface can be viewed withjava -jar
lib/resin.jar
help. Documentation for a particular command can be viewed with
java -jar lib/resin.jar help <command>

maven/junit embedding/integration with JPA/data sources

When embedded Resin is launched inside a maven/junit task, the default
behavior is to disable Resin's Alarm, which manages timeouts. To re-enable
the alarm, use a '-Dcaucho.alarm-enable' on the command-line when launching
Java.

The alarm is disabled in embedded cases to handle of embedded
Quercus in a non-Resin container.

WebSocket draft v7

Resin's WebSocket support has been upgraded to the test v7 draft of the
IETF specification.

Change List

watchdog: set the LD_LIBRARY_PATH_64 variable on 64-bit systems (#4536)

access-log: rollover rescheduling of alarm was not reliable (#4540, rep by mros2stf)

ant-plugin: ant plugin has been moved to http://github.com/caucho/ant-plugin

command-line - added support for log-level, profile, heap-dump and thread-dump.

Web Profile TCK

EL - pass

EJB - pass

JDBC - pass

JMS - pass

JPA - pass

JSF - pass

JSP - pass

JSR-299 (CDI) - pass

JSR-330 (javax.inject) - pass

JSTL - pass

JTA - pass

Servlet - pass

Dynamic Server Cloud Support

Resin 4.0.17 finishes up our dynamic cloud support, putting the
final piece together. You can now add and remove a new dynamic server to
the cluster, and Resin's cloud will update to support the new server
automatically.

In this example, the mbean('java.lang:type=Runtime') function looks up an
MBean in JMX, and '.BootClassPath' retrieves the attribute value. The
=~ operator matches the value to a regular expression. <health:Not>
qualifies the predicate to match on a failure. This is a useful check to
alert if a required jar is not present in the boot classpath.

JMX Meter Updates

A number of previously hard-coded JMX meters are now setup in health.xml.
Meters provide graphing in /resin-admin. Any numeric MBean attribute can be
graphed using the new <health:JmxMeter> or <health:JmxDeltaMeter>
elements.

JmxMeter graphs the current value, while JmxDelta meter graphs
the different between the current and previous values. /resin-admin uses the
pipe | character in the <name> attribute to enhance the UI by
categorizing meters into drill-downs.

(CLI) Resin command line updates

Resin 4.0.17 introduces commands to produce thread and heap dumps, change log
levels and profile applications. Documentation for an updated CLI interface
can be viewed with java -jar lib/resin.jar help. Documentation for
a particular command can be viewed with java -jar lib/resin.jar help <command>

HMTP/BAM API changes

The HMTP/JMTP messaging APIs continue to change as we work on simplifying
the model. Resin uses HMTP/BAM as its internal clustered
messaging framework.

We now have 5 base classes:

MessageStream - the underlying stream for the unidirectional and request/response messages

Actor - the actor/service interface for an application service.

Mailbox - the queue receiving messages for the actor.

Broker - the router to dispatch messages to other actors' mailboxes.

BamManager - manages adding and removing actors from a broker system.

rewrite-dispatch

The rewrite-dispatch order has been normalized. This should be invisible
for most users, Resin now has a better-defined order for dispatching.

All requests now go through the following order (basically a servlet filter chain order.)

rewrite-dispatch order

security (checked first)
rewrite-dispatch
filters
servlet

Since dispatch actions like <resin:LoadBalance> and
<resin:HttpProxy> are rewrite-dispatch rules, this means
that security will be applied, but servlet filters will not be applied.

proxy cache

The proxy cache has been refactored internally to better handle exceptions
and disconnects while filling the cache. The decision to make a request a
cache-fill thread now happens at the top filter call, which allows the
cleanup logic to be a simple "finally" block.

{SSHA} authentication passwords

Resin's authenticators now support LDAP-style {SSHA} passwords for
all the built-in authenticators, or anyone extending
from AbstractAuthenticator.

load-balance/cluster pools split

The load-balance and cluster TCP socket pools are now split and
using different timeouts. The cluster socket pool is used for HMTP/BAM
messages for heartbeat, dist-cache, repository, etc. The load balance
pool is used for <resin:LoadBalance>, <resin:HttpProxy> and
<resin:FastCgiProxy.

Change List

rewrite-dispatch: normalization of rewrite order so rewrites always occur before filters

Resin Eclipse plugin update

WebSocket API Update

We've updated the WebSocket API based on changes to the draft
IETF specification, available in com.caucho.websocket.*. Since the
specification itself is moving very slowly (but in incompatible ways),
Resin's WebSockets can only be used with its own WebSocket client.

BAM Update

BAM has been updated to a cleaner Broker-Actor-Mailbox model,
more closely matching traditional Actor APIs.

Comet/Async Updates

The Comet/Async networking code has been reworked, fixing some callback
timing behavior with complete() calls.

Resin 4.0.13

2010-11-10

Description

Resin 4.0.13

Resin 4.0.13 finishes the first pass over the EJB TCK. Because of
regression work (particularly with CDI regressions related to the EJB
TCK work), the complete Web Profile pass will be the main focus of 4.0.14.

Resin 4.0.6

2010-04-12

Description

Resin 4.0.6 Overview

ipv6 support

<class-loader> config changes

documentation reorganization

JavaEE 6 Web Profile TCK progress

passes Servlet TCK for JavaEE 6

passes JSP TCK for JavaEE 6

class-loader config changes

The <class-loader> configuration behavior was previously confusing,
and has been updated. Now, class loaders add added in the order they are
defined in the resin.xml, and their search order is the same as the
resin.xml order.

To change the priority, you can use the <prologue> tag to force
evaluation in the <prologue> pass. This will cause your classloader to
be defined before any classloader in the standard pass.

documentation reorganization

The documentation has been reorganized to split the
reference (basically tags) from the explanatory section.

Servlet 3.0 TCK for Web Profile

Passing the Servlet 3.0 TCK in 4.0.4 is the first step for Resin to complete
the JavaEE-6 Web Profile. The web profile is our primary focus for the
next few months. It's the "good bits" of JavaEE-6: all the specifications
aimed at developing web applications without the legacy enterprise
requirements like CORBA that only specialized applications use.

Our plan is to continue passing new TCKs for each of the next
few 4.0.x releases until we are done with the web profile.

Embedded ResinContext

The new embedded ResinContext lets you use Resin's CanDI and EJB
environment in a non-Resin context like a JUnit test or even in a
standalone application.

The simplest use of Resin context scans for *.jar files with CanDI
beans.xml or EJB ejb-jar.xml files and lets you start a CanDI
request scope.

Configuring beans

You can configure the beans XML using the same environment
tags as are available to the resin.xml and resin-web.xml like
<mypkg:MyBean> for CanDI, <database> for databases, and
<resin:import> to include files.

In addition to the major language changes, Quercus has completed its
support for variable class methods and late static binding, both features
are used in new-generation PHP frameworks to improve templating power and
clarity.

Change List

jni: improved error messages

hessian: custom deserializer (#3632, rep by era)

configure: check for cp -u (#3888, rep by Kaminsky, Leonid)

configure: standardize default resin root, conf, and log directories

web-app: web-app deploy with archive-and root-directory was not propery set (#3887, #3873, rep by chiefgeen)

Servlet 3.0 Early Access

Resin 4.0.2 continues work on the Servlet 3.0 draft specification as
an early access release.

Java Injection (JSR-299, JSR-330, CanDI)

The Java Injection specification has changed significantly between 4.0.1
and 4.0.2. Resin now supports the JSR-330 annotations for Java Injection.

The main changes are repackaging and renaming of the key injection
annotations to match JSR-299. The Java Injection Tutorial
has been updated for the new injections.

Clustered JMS Queues and Topics

Resin's clustering now includes support for clustered queues and topics.
The primary clustered queue is a singleton queue with failover. The clustered
topics notify all servers in a cluster pod.

/resin-admin

We've added /resin-admin features to improve visibility to the server,
development and debugging, and adminstration.

The "summary" tab now includes statistical gathered as the server is
running including request counts, request times, CPU time, netstat reports,
and database activity.

A "postmortem" tab helps debugging of a server crash by displaying
the server state at the time just before a restart.

Customized statistics gathering based on JMX is now available through
the <jmx> and <jmx-delta> tags of the <resin:StatManager> service.

Customizable REST pages are now available through /resin-admin using PHP
to script the gathered data. The REST capability is intended for integration
with administration tools like Nagios.

Distributed Deployment

Distributed deployment has been enhanced with staging and versioning
capabilities, and integrated with the development flow with ant and maven
tasks.

A new application version can be deployed with the following process:

Upload the .war contents transactionally to the server (but not activated yet)

Deploy and test a "staging" version on a single machine.

Activate the .war for the production servers.

Quercus: Availability on other Application Servers

Quercus development in 4.0.2 has focused on bugs fixes and QA regression
cleanup.

WebSocket, HMTP, and JMTP support

Resin 4.0.2 now includes support for the HTML 5 WebSocket protocol, which
is a fully-bidirectional TCP connection established using HTTP handshaking,
allowing for true interactive applications with HTML 5 browsers.

On top of WebSockets, we've created JMTP and HMTP as a programmable
messaging layer. JMTP (JSON Message Transport Prototocol) and
HMTP (Hessian Message Transport Protocol) provide general
messaging, RPC, and publish/subscribe capabilities in a clean, simple
interface.

Quercus Pro support for other application servers, and increased
support for Google App Engine.

Stability and performance work for clustered caching and sessions

Resin 4.0.x is the active development branch. Due to the addition of
new features, it may be more unstable than the production branch.

The 3.1.x branch is the stable branch.

Servlet 3.0 Early Access

Resin 4.0.1 has implemented the Servlet 3.0 draft specification as
an early access release. Importantly, Resin's server
push/comet support has changed to the Servlet
AsyncContext model. Developers who have used Resin's experimental comet API
should see the new comet
using AsyncContext tutorial. Future Resin versions will concentrate on
the AsyncContext API and will eventually drop the experimental API.

/resin-admin

We've added /resin-admin features to improve visibility to the server,
development and debugging, and adminstration.

A new "graphs" tab lets you view recent statistics from the servers.
When viewed from the first triad server, statistics from all the servers in
the cluster are available.

A new "SQL" tab allows you to browse the schema and make queries to
any configured database pool in the server.

A new "Wizards" tab helps new users configure various parts of the
server by showing XML syntax and options. Currently only database pool
configuration is supported, with other wizards coming in future releases.

Watchdog

The command-line to start Resin now requires an explicit "console" for
console-mode, because some users were using unix background processing instead
of using the "start" command.

The watchdog-Resin socket now uses HMTP/BAM for communication. On
shutdown, this lets the watchdog close Resin gracefully before forcing
an exit.

Distributed Deployment

The distributed deployment reliability has been enhanced by adding
automatic retry on restart. If a triad server is not yet available when
a server starts, Resin will continue retry the server until the triad is
up and available.

Ubuntu/Debian 64-bit packages

.deb packages are now provided for both Resin Open Source and Resin
Professional for 32-bit and 64-bit x86 architectures.

Quercus: Availability on other Application Servers

Quercus Professional is now available on any JavaEE application server
with the quercus-pro.war download.

Change List

session: save-mode='before-header' should not serialize sessions after the request (rep by Gagan Chaudhari)

Resin 4.0.x

Resin 4.0.x is now the development branch. Due to the addition of
new features, it may be more unstable than the production branch.

The 3.1.x branch is the stable branch.

Resin 10,000

Resin's concurrent connections has been tested up to 10,000
simultaneous keepalive connections. Since the CPU usage of that test was only
1.0, the actual upper limit would be even larger than 10k.

Java Injection (JSR-299, CanDI)

Resin's configuration and dependency injection is based on the
JSR-299 (CanDI) draft specification. Applications can use Java Injection
to create and configure custom components, including configuration of
third party libraries.

Distributed Deployment

New .war versions can be deployed to a distributed cluster. All servers
in the cluster will receive the new .war updates. Updates are incremental,
with only changed files requiring new uploads. Plugins for distributed
.war are available for eclipse, ant, and maven.

Distributed JMX

Eclipse Plugin

The eclipse plugin has been rewritten to include remote distribution
of .war files, and improve remote control of Resin instances..

Maven Project jar Repository

Project and library jar files may now be placed in
a project-jars directory, and selected using a WEB-INF/pom.xml
in Maven project syntax. Resin will resolve the jars in the project-jars
directory based on the pom.xml, selecting appropriate versions, and
avoiding duplicate jar deployment.

rewrite redesign

Resin's rewrite rules have been improved to allow easier customization and
configuration based on CanDI style configuration.