• JDK 6 compability
• Distributed session database synchronization issues

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.

Quercus

Quercus encoding issues with MySQL databases have been resolved.

BAM/Actor Worker Thread Fixes

Updated the thread launching for workers threads to avoid possible synchronization issues.

AnomalyAnalyzer

Added min-threshold and max-threshold to AnomalyAnalyzer and min-value and max-value, to limit overzealous analyzer reports.

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.

@HandlesTypes scanning

The ServletContainerInitializer @HandlesTypes was not properly implemented in Resin 4.0. This has been fixed.

Tiered Caching

Resin's jCache implementation now supports tiered caching. The secondary tier can be used like memcache to support sharded, replicated, and persistent caching.

JDBC Caching

JDBC-style caching and session replication now supported again with Resin 4.0. With Resin 4.0, the JDBC cache serves as a backing store. Resin's main cache acts like a side-cache.

• Restart report no longer requires a JMX dump to produce data.
• Heartbeat and cluster system function reliability under freeze conditions.
• deploy with --host now properly uses directory.

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.

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.

CLI: dynamic server clarification

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

As before, the "--cluster" option tells Resin which cluster to join.

unix> resinctl start --elastic --cluster app

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

1. Significant work on the cache/session store to better handle garbage-collection of old data.
2. Improved internal network/messaging to improve code readability.
3. Cloud/deployment for cluster deploy and cross-pod updates.
4. JSP/EL low-level fixes.

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

Resin 4.0.27 is primarily a reliability and performance release.

Resin's performance and threading scalability have been improved considerably in Resin 4.0.27.

We've replaced locking has with non-locking atomic operations, cleared contention bottlenecks, improved the async/epoll performance, and reduced thread overhead.

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.

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

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.

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

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.

...
public void service(WebSocketContext ws)
{
  WebSocketEncoder<MyMsg> myEncoder = new MyWebSocketEncoder();

  BlockingQueue<MyMsg> queue = ws.createOutputQueue(myEncoder);

  queue.offer(new MyMsg("my-data"));
}  

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

Resin's thread pool has been updated to improve the efficiency and reduce the number of threads spawned. Applications with spiky load should see better performance and lower overall thread use.

Resin's thread pool is described in Resin Application Server: Thread Pool.

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.

Resin's static file serving is described in Resin Web Server: Static Files.

Resin's jCache implementation has been updated, adding the new @CacheResult, and @CachePut Java Dependency Injection (CDI) annotations, which enable caching for any CDI-enabled bean.

A short tutorial is available at Java Cache Tutorial with Dependency Injection Method Annotations.

There is also a short tutorial on using the Java API for jCache at Java Cache Tutorial with Cache Dependency Injection (CDI).

Resin's command line interface introduces a new command that deletes deployed configuration

    # deploy configuration
    resinctl config-deploy conf.jar
    # undeploy configuraton
    resinctl config-undeploy
  

Capability to save PDF report was added to pdf-report command.

    # create pdf-report
    resinctl pdf-report -local -local-dir /tmp
  

The PDF report is described in Resin Health System: PDF Report.

The command-line interface is described in Resin Application Server: Command Line Interface.

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

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

    curl  --user admin:secret http://localhost:8080/resin-rest/jmx-list
  

An overview of the REST interface is available at Resin Application Server: REST Interface.

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.

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:

# report on the last restart
bin/resin.sh pdf-report -user admin -password secret -watchdog 
# report on the last 24 hours
bin/resin.sh pdf-report -user admin -password secret -shapshot 

The form-parameter-max element in the <web-app> restricts the maximum number of parameters in a form. The default value is 10,000.

Resin's WebSocket implementations now passes the protocol tests for the final RFC version of WebSockets.

Passwords for databases and custom configuration can now be scrambled using the <resin:Password> tag in the config file.

<web-app xmlns="http://caucho.com/ns/resin"
      xmlns:resin="urn:java:com.caucho.resin">

  <database jndi-name="jdbc/mysql">
    <driver type="com.mysql.jdbc.Driver">
      <url>jdbc:mysql://localhost:3306/test</url>
      <user>resin</user>
      <password>
        <resin:Password value="{RESIN}zZEEvYw4uxuyJotZf39bBw=="/>
      </password>
    </driver>
  </database>
</web-app>

The encrypted password can be generated on the command line with the password-encrypt command:

unix> resinctl password-encrypt changeme
password: {RESIN}zZEEvYw4uxuyJotZf39bBw==

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.

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.

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".

The sample resin.xml has been updated and split into a sample "cluster-default.xml" to better show the base 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.

my-cloud-conf/admin-users.xml
my-cloud-conf/resin-inf/mysql.xml
my-cloud-conf/resin-inf/lib/mysql.jar

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

unix> resinctl config-deploy my-cloud-conf

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.

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.

4.0.24 introduces the resin.properties and configuration simplification to make cloud deployments simpler. It also includes new memcache support.

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

RPMs are now available for Resin-Pro

unix> sudo rpm --import http://caucho.com/download/rpm/RPM-GPG-KEY-caucho
unix> sudo yum install http://caucho.com/download/rpm/4.0.24/x86_64/resin-pro-4.0.24-1.x86_64.rpm

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.

log_level     : info
dev_mode      : true
resin_doc     : true

app_tier      : 192.168.1.10 192.168.1.11
web_tier      : 192.168.1.20

http          : 8080
app-0.http    : 8081

setuid_user   : resin
setuid_group  : resin

jvm_args      : -Xmx2048m

system_key    : changeme
admin_enable  : true
admin_user    : admin
admin_password: {SSHA}xxxxxxx

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 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.

<resin xmlns="http://caucho.com/ns/resin"
      xmlns:resin="urn:java:com.caucho.resin">

  <resin:properties path="http://169.254.169.254/latest/user-data"
                    optional="true">

</resin>

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'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.

The resin.xml to implement the local.d looks as follows:

<resin xmlns="http://caucho.com/ns/resin">

  ...
  <resin:import fileset="${__DIR__}/local.d/*.xml"/>

  ...
</resin>

The standard resin.xml now includes openssl configuration. To enable openssl, upload the certificate files and update the resin.properties.

openssl_file : keys/gryffindor.crt
openssl_key : keys/gryffindor.key
openssl_password : changeme

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.

app_tier : 192.168.1.10 192.168.1.11:6801 192.168.1.12:6802
http     : 8080

The configuration for the app_tier is in the default resin.xml

<resin xmlns="http://caucho.com/ns/resin">
 ...
 <cluster id="app-tier">

   <server-multi id-prefix="app-" address_list="${app_tier}" port="6800">
   </server-multi>
   ...
 </cluster>
</resin>

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.

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.

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

unix> resinctl license-add 1013009.license

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.

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.

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.

<web-app xmlns="http://caucho.com/ns/resin"
  xmlns:memcache="urn:java:com.caucho.memcache">

  <memcache:MemcacheClient cluster="cache-tier" port="11212"/>

</web-app>

package example;

import javax.inject.*;
import javax.cache.*;

public class MyBean {
  @Inject Cache _memcache;
}

Resin can also be configured as a memcache server. The following <listen> configures it.

<resin xmlns="http://caucho.com.ns/resin"
    xmlns:memcache="urn:java:com.caucho.memcache">

  <cluster id="cache_tier">

    <server-multi id-prefix="cache-"
                  address-list="${cache_tier}"
                  port="6820">

      <listen port="${rvar('memcache_port')?:11212}"
              keepalive-timeout="600s" socket-timeout="600s">
        <memcache:MemcacheProtocol/>
      </listen>
    </server-multi>
  </cluster>
    
</resin>

User credentials established with Windows Authentication are made available in Resin's HttpServletRequest.getRemoteUser() and HttpServletRequest.getUserPrincipal()

4.0.23 continues focus on bug fixes and stability

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

The PdfReport now has a mail-to attribute which can be used to send the pdf report as an email attachment.

<resin ...>
  <cluster ...>
  
      <health:PdfReport>
        <path>${resin.home}/php/admin/pdf-gen.php</path>
        <report>Watchdog</report>
        <watchdog/>
        <mail-to>user@example.com</mail-to>
        <health:OnRestart/>
      </health:PdfReport>

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.

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.

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

The WebSocket implementation has been upgraded to draft 16.

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.

4.0.21 continues focus on bug fixes and stability. 4.0.21 includes significant reworking of the networking state machine for keepalive timing issues.

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

Resin cli added error codes for specific failures e.g. authentication error, wrong argument, deployment error.

Added a new command that makes resin boot process compatible with requirements of launchd (Mac OSX). 'start-with-foreground' command is an extension of 'start' command that keeps resin boot process running.

Deprecated 'watchdog' command. 'watchdog' command will still work, however, we recommend that 'start-with-foreground' is used instead.

Better error reporting was added to let users know of git deployment failures.

Download and install functionality updated to install into version specific directory.

Threads page was tweaked to sort threads by stack trace.

Graphing enhancements continue, with improved scrolling control.

New health actions and conditions:

• <health:OnAbnormalStop> - A condition that fires only when Resin stops unexpectedly.
• <health:DumpJmx> - A health action that creates a concise snapshot of all JMX MBean attributes and values.
• <health:Snapshot> - A sequence of health actions: thread dump, heap dump, jmx dump, pdf report.

A Snapshot on OnAbnormalStop condition was added by default to health.xml. If upgrading we recommend you add this to your existing health.xml.

  <health:Snapshot>
    <health:OnAbnormalStop/>
  </health:Snapshot>

The PDF has been expanded to include heap, cpu profile, thread dump, and JMX data. This additional data gives a fuller snapshot of the JVM's state.

unix> bin/resin.sh pdf-report
generated /usr/local/home/ferg/test/resin-pro-4.0.21/log/default-Summary-20110819T1434.pdf

unix> bin/resin.sh pdf-report -profile-time 60
generated /usr/local/home/ferg/test/resin-pro-4.0.21/log/default-Summary-20110819T1434.pdf

The WebSocket implementation has been updated to the latest draft specification.

Resin's WebSocket implementation is stream based, meaning arbitrary-length messages are supported.

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.

package com.caucho.websocket;

public interface WebSocketListener {
  public void onReadBinary(WebSocketContext, InputStream is)
    throws IOException;
    
  public void onReadText(WebSocketContext, Reader is)
    throws IOException;
}

Messages are written using the WebSocketContext. The application starts new message with startBinaryMessage() or startTextMessage(), writes to the OutputStream and closes it on message end.

package com.caucho.websocket;

public interface WebSocketContext {
  public OutputStream startBinaryMessage()
    throws IOException;
    
  public PrintWriter startTextMessage()
    throws IOException;
}

We've been tracking the jcache specification updates. Jcache will provide a standard caching API. The latest changes include compare-and-set operations

4.0.20 continues focus on bug fixes and stability. 4.0.20 includes significant reworking of the networking state machine for comet/async timing issues.

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

PDF reports are now available from the /resin-admin summary page and the postmortem. The PDF gathers the summary graphs into a single document.

PDF reports can now be generated on a timed basic (daily or weekly). The new PdfReport health action creates a summary pdf in the resin/log directory for an overview of the server operation.

<resin xmlns="http://caucho.com/ns/resin"
       xmlns:resin="urn:java:com.caucho.resin"
       xmlns:health="urn:java:com.caucho.health">

  ...     
  <resin:import path="${__DIR__}/health.xml" optional="true"/>

  <health:PdfReport>
    <report>Summary</report>
    <health:IfCron value="0 0 * * 0"/>
  </health:PdfReport>
  
  ...
</resin>  

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.

The custom graph pages can also be used for the PDF reports.

<resin ...>

  ...
  
  <health:MeterGraphPage>
    <name>Threads</name>
    <period>6h</period>
    <columns>3</columns>
      
    <graph name="Threads">
      <meter>JVM|Thread|JVM Thread Count</meter>
      <meter>Resin|Thread|Thread Count</meter>
      <meter>Resin|Thread|Thread Idle Count</meter>
      <meter>JVM|Thread|JVM Runnable Count</meter>
      <meter>JVM|Thread|JVM Blocked Count</meter>
      <meter>JVM|Thread|JVM Native Count</meter>
      <meter>JVM|Thread|JVM Waiting Count</meter>
    </graph>
  </health:MeterGraphPage>

</resin>

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 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.

Resin Eclispe Snapshot and Release update sites are:

• Eclipse Plugin Release Update Site
• Eclipse Plugin Snapshot Update Site

• All style and content was updated to pass W3C HTML validation and follow W3C accessibility guidelines.
• The Web Applications page was updated to include an option to undeploy an application.
• Graphs now allow pan and zoom.

In addition a few new health conditions and actions, all applicable command line actions are now also available as health actions.

• <health:IfNotRecent> - Condition that throttles actions to execute no more than once per period.
• <health:ActionSequence> - An action that executes a series of child actions in sequence.
• <health:FailSafeRestart> - Initiates a delayed guaranteed restart of Resin.
• <health:StartProfiler> - Starts a performance profiling session.
• <health:CallJmxOperation> - Calls a JMX MBean operation.
• <health:SetJmxAttribute> - Sets a JMX MBean attribute.

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.

<cluster xmlns="http://caucho.com/ns/resin"
         xmlns:resin="urn:java:com.caucho.resin"
         xmlns:health="urn:java:com.caucho.health"
         xmlns:ee="urn:java:ee">
         
  <health:ActionSequence>
    <health:FailSafeRestart timeout="10m"/>
    <health:DumpThreads/>
    <health:DumpHeap/>
    <health:StartProfiler active-time="5m"/>
    <health:Restart/>
    <health:IfHealthCritical time="5m"/>
    <health:IfNotRecent time="10m"/>
  </health:ActionSequence>

</cluster>

4.0.18 is primarily a bug fix release.

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>

Resin Ant Plugin has been moved to a new home at github: https://github.com/caucho/ant-plugin.

Changes to the health system this release include improved stability, logging, documentation, and lifecycle conditions.

• Parameter checking and error reporting - All health checks, actions, and conditions were updated to check for missing or invalid attributes and report clearer error logs.
• Documentation - Full documentation of the health checking system is now present at /resin-doc/admin/health.xtp.
• Lifecycle conditions - Resin can now be configured to execute health actions on startup, shutdown, and restart.

<cluster xmlns="http://caucho.com/ns/resin"
         xmlns:health="urn:java:com.caucho.health">

  <health:SendMail>
    <to>admin@yourdomain.com</to>
    <health:OnStartup/>
  </health:SendMail>
 
</cluster>

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.

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

4.0.17 includes Web Profile TCK, JMS, cloud, health, eclipse plugin, and command-line work

• Web Profile TCK - now passing all Web Profile TCK sections
• JMS - now passing JMS TCK
• cloud - dynamic -join-cluster added
• health - configurable JMX meters for graphing, and many added health predicates.
• command-line - added support for log-level, profile, heap-dump and thread-dump.

• 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

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.

• Resin load balancing automatically uses the new server.
• The new server gets the latest application .war.
• JMS Queue sender/receivers work with the new server.
• JMX clustered management works with the new server.
• Clustered caching data is shared with the new server.

unix> java -jar lib/resin.jar -join-cluster app-tier -server dyn1 start

Enhancements to the health check system continue with the following new command available.

• <health:IfFlapping> - predicate that qualifies an action to match on frequent state changes.
• <health:IfCron> - predicate that qualifies an action to match if the current time is in an active range configured using cron-style syntax.
• <health:IfExpr> - predicate that qualifies an action to match on the evaluation of a JSP EL expression.
• <health:ExprHealthCheck> - check that evaluates one or more JSP EL expressions to a health status.
• <health:ExecCommand> - action that executes a shell command.

<health:IfExpr> and <health:ExprHealthCheck> work well in combination with enhancements made to EL syntax that enables JMX access and regular expression evaluation.

<cluster xmlns="http://caucho.com/ns/resin"
         xmlns:health="urn:java:com.caucho.health">

  <health:SendMail>
   <to>admin@yourdomain.com</to>
    <health:Not>
      <health:IfExpr test="${mbean('java.lang:type=Runtime').BootClassPath =~ '.*resource-16.jar.*'}"/>
    </health:Not>
  </health:SendMail>
 
</cluster>

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.

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.

<cluster xmlns="http://caucho.com/ns/resin"
         xmlns:health="urn:java:com.caucho.health">

  <health:JmxMeter>
    <name>JVM|Thread|JVM Thread Count</name>
    <objectName>java.lang:type=Threading</objectName>
    <attribute>ThreadCount</attribute>
  </health:JmxMeter>

  <health:JmxDeltaMeter>
    <name>JVM|Compilation|Compilation Time</name>
    <objectName>java.lang:type=Compilation</objectName>
    <attribute>TotalCompilationTime</attribute>
  </health:JmxDeltaMeter>

</cluster>

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.

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>

Commands added in release 4.0.17 are thread-dump, heap-dump, log-level, profile

Eclipse plugin has undergone significant updates, with configuration, deployment and debugging reworked. Added option for remote deployment. Bugs #4417, #4418 are resolved.

Removing the older version of plugin is necessary for a smooth update. Procedure for complete removal of the plugin is outlined at http://bugs.caucho.com/view.php?id=4417

Updates to NetBeans plugin resolve bug #3936 and changes deployment option to exploded web-app directory deploy.

4.0.16 has primarily been a bug-fix release.

• EL - pass
• EJB - pass
• JDBC - pass
• JPA - pass
• JSF - pass
• JSP - pass
• JSR-299 (CDI) - pass
• JSR-330 (javax.inject) - pass
• JSTL - pass
• JTA - pass
• Servlet - pass

The health check system has been enhanced, allowing for more control of Resin restarts and logging. The configuration is still in progress, and can be seen in the conf/health.xml file.

The health configuration follows the same pattern as the rewrite rules. Each action has a set of optional predicates that tell when the action should occur.

<cluster xmlns="http://caucho.com/ns/resin"
         xmlns:health="urn:java:com.caucho.health">

  <health:CpuHealthCheck>
    <warningThreshold>95</warningThreshold>
    <criticalThreshold>99</criticalThreshold>
  </health:CpuHealthCheck>
  
  <health:DumpThreads>
    <health:IfCriticalRechecked time="2m" healthCheck="${cpuHealthCheck}"/>
  </health:DumpThreads>
</cluster>

In the example, the <health:IfCriticalRechecked> predicate is true if the CpuHealthCheck returns a critical value for 2 minutes. This will avoid log a thread dump for a temporary CPU spike.

Resin 4.0.16 has implemented draft-6 of the web socket protocol. A Resin WebSocket Tutorial is available.

Resin's API is based on the stream model of the Servlet API, using OutputStream and PrintWriter to send messages and InputStream and Reader to receive messages.

package com.caucho.servlet;

public interface WebSocketContext
{
  public OutputStream startBinaryMessage() throws IOException;

  public PrintWriter startTextMessage() throws IOException;

  public void setTimeout(long timeout);

  public long getTimeout();

  public void close();
  
  public void disconnect();
}

package com.caucho.servlet;

public interface WebSocketListener
{
  public void onStart(WebSocketContext context)
    throws IOException;
  
  public void onReadBinary(WebSocketContext context, InputStream is)
    throws IOException;

  public void onReadText(WebSocketContext context, Reader is)
    throws IOException;

  public void onClose(WebSocketContext context)
    throws IOException;

  public void onDisconnect(WebSocketContext context)
    throws IOException;

  public void onTimeout(WebSocketContext context)
    throws IOException;
}

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.

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.)

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.

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.

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

<web-app xmlns="http://caucho.com/ns/resin"
         xmlns:resin="urn:java:com.caucho.resin">
  
  <resin:XmlAuthenticator>
     <user name='harry' password='{SSHA}Vug/pmSPPOTh/dCG2GpDE6BIE+1zYWx0'/>
     <user name='draco' password='{SSHA}H9STJXP1NwWBy1VIL+6cVQPEMtxzbmFrZQ=='/>
  </resin:XmlAuthenticator>

</web-app>  

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.

4.0.15 has primarily been a bug-fix and Web Profile TCK release. It also encludes several extensions and enhancements to the HealthCheck system.

• EL - pass
• EJB - 1 fail (timing, possible TCK bug)
• JDBC - pass
• JPA - 8 fail (exception)
• JSF - pass
• JSP - pass
• JSR-299 (CDI) - pass
• JSR-330 (javax.inject) - pass
• JSTL - pass
• JTA - pass
• Servlet - pass

The Resin eclipse plugin has been updated at http://caucho.com/eclipse.

The plugin allows automatic download of Resin Professional.

The health check system has been enhanced, allowing for more control of Resin restarts and logging.

• EL - pass
• EJB - 1 fail (timing, possible TCK bug)
• JPA - pass
• JSF - pass
• JSP - pass
• JSR-299 (CDI) - 1 fail (disputed TCK test)
• JSR-330 (javax.inject) - pass
• JSTL - 1 fail (ordering issue with map, possible TCK bug)
• JTA - pass* (*JTA TCK includes CORBA tests which aren't required by WebProfile)
• Servlet - pass

The Resin eclipse plugin has been updated at http://caucho.com/eclipse.

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 has been updated to a cleaner Broker-Actor-Mailbox model, more closely matching traditional Actor APIs.

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

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.12 is a bug fix release.

• Fixes to remote deployment and .git for performance and stability.
• Database pool refactoring for monitoring and overflow conditions.
• Database pool refactoring for ping updates
• Persistent logging updated for administration
• XA detach pooling from user transaction
• HTTP Proxy Cache fixes for deployment and restart

Remote deployment has been revised and improved to increase reliability and improve clustering performance.

Deployment of .war files is now integrated with remote deployment so Resin now uses one unified mechanism. Checking of .war versions is now available across the cluster in the webapps tab.

Remote deployment is now available in /resin-admin, from the command-line, and from ant. Remote deployment in /resin-admin is in the web-apps tab.

The HealthCheck is now integrated with JMX and with the statistics generation. The HealthCheck is now displayed in /resin-admin in the health tab.

The Heartbeat timings have been improved. The current heartbeat status is now available in /resin-admin in the health tab.

The /resin-admin Thread dump has been revised, adding locking information from the JDK 6 thread dump.

Locking groups of the thread dump are now displayed in the lock tab of the thread dump.

The postmortem tab in the /resin-admin now includes statistics on the health services.

The CPU profile and heap dump tabs now have pie charts to better display the total memory use.

The Graphs tab of /resin-admin has been revised to dynamically update the graph based on the meter choices.

The Graphs tab now included new display modes to improve cross-cluster graph displays.

Resin 4.0.10 is a stability/bug fix release.

There is an important Alarm fix where the Resin timers could be frozen, causing sessions to not expire and <ping> timers to not fire .

WebServiceContext is now available for CXF as an @Inject or a @Resource, when deploying a CXF WebService through the servlet interface.

The ping capabilities have been generalized and refactored into a general health service that checks the Resin health every 60 seconds.

Resin exits and restarts are now logged with more information, giving the reason in both the watchdog and jvm logs.

ResinEmbed how has a setRootDirectory and the WebAppEmbed has a setArchivePath to match the <root-directory> and <archive-path> tags in the resin.xml.

JPA: eclipselink properties for Resin JTA were not properly set when eclipselink was discovered using scanning.

Resin 4.0.9 is a stability/bug fix release.

The ThreadPool has been reworked to replace synchronization with atomic variables.

The distributed cache/session backing-store has been revamped to replace its locking system and replace synchronization with atomic variables.

Network startup has been broken into systems to simplify startup order and improve testability.

Resin 4.0.8 has completed the CDI implementation for the JavaEE Web Profile

The current list of completed Web Profile components is:

• Servlet
• JSP
• CDI

Resin 4.0.7 is an interim CDI/EJB and bug fix release; the following release 4.0.8 is planned to be the full CDI TCK completion. People using CDI/EJB heavily may want to wait for the 4.0.8 release.

Resin 4.0.7 adds resin:IfMBeanEnabled and resin:MovedPermanently to the rewrite rules.

• ipv6 support
• <class-loader> config changes
• documentation reorganization

• passes Servlet TCK for JavaEE 6
• passes JSP TCK for JavaEE 6

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.

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

• JSP for JavaEE 6 Web Profile passes TCK
• Hibernate second level cache
• @TransactionScoped
• Windows setup.exe/resin.exe refactor
• java.util.logging Handler integration with CDI
• distributed session store bugs

4.0.5 now passes the JSP TCK of the Web Profile, joining the Servlet TCK passed in 4.0.4.

<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence">
  <persistence-unit name="test">
    <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <jta-data-source>jdbc/mysql</jta-data-source>

    <properties>
      <property name="hibernate.cache.use_second_level_cache"
                value="true"/>
                
      <property name="hibernate.cache.provider_class"
                value="com.caucho.hibernate.ResinCacheProvider"/>

    </properties>
  </persistence-unit>
</persistence>

Resin's CDI now supports @com.caucho.config.TransactionScoped, which gives your beans a lifecycle exactly matching a transaction.

Custom java.util logging handlers can now be configured by CDI.

<resin xmlns="http://caucho.com/ns/resin"
   xmlns:logging="urn:java:java.util.logging">

  <logger name="com.foo" level="fine">
    <logging:SocketHandler host="my-host" port="8000"/>
  <logger>
  
  ...
</resin>

• Pass Servlet 3.0 TCK for JavaEE 6 web profile
• com.caucho.resin.ResinBeanContainer for embedded Resin use
• com.caucho.junit.ResinJUnitRunner for embedded junit use
• Quercus support for PHP 5.3 Namespaces
• Quercus support for PHP 5.3 Closures

Resin 4.0.x is the active development branch.

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.

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.

import com.caucho.resin.*;

public class MyMain {
  static void main(String []argv)
  {
    ResinBeanContainer resinContext = new ResinBeanContainer();

    // scan classpath and initialize @Startup beans
    resinContext.start();

    // start a new request
    RequestContext cxt = resinContext.beginRequest();

    try {
      MyBean bean = cxt.newInstance(MyBean.class);

      bean.doStuff();
    } finally {
      cxt.close();
    }
  }
}

<beans xmlns="http://caucho.com/ns/resin"
   xmlns:lang="urn:java:java.lang"
   xmlns:ee="urn:java:ee">

  <mypkg:MyBean xmlns="urn:java:com.mycom.mypkg">
    <my-field>my-value</my-field>
  </mypkg:MyBean>

  <lang:String>
    <new>my-config-value</new>
    <ee:Named>my-config-name</ee:Named>
  </lang:String>

  <database name="my-db">
    <driver type="..." url="..."/>
  </database>
    
</beans>

The ResinBeanContainer has an associated JUnit @RunWith runner, letting you create JUnit tests for your model code in Resin's CDI environment.

package qa;

import org.junit.*;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
import com.caucho.junit.ResinBeanContainerRunner;
import javax.inject.*;

@RunWith(ResinBeanContainerRunner.class)
@ResinBeanConfiguration(beansXml="test.xml")
public class MyTest {
  @Inject MyBean _myBean;
  
  @Test public void simpleTest()
  {
    assertTrue(_myBean != null);
  }
}

Quercus in 4.0.4 has implemented the namespaces and closures capabilities of PHP 5.3. Namespaces finally give PHP the ability to isolate functions and classes with unique names.

Closures add functional programming capabilities to PHP, giving power to more powerful event-driven frameworks.

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.

The focus of Resin 4.0.2 development was the following:

• CanDI updates to match changes to the JSR-299 and JSR-330 specifications.
• Servlet 3.0 early access updates
• Continued EJB Lite development
• Clustered/Cloud .war deployment enhancements, including staging, versioning, and ant/maven tasks.
• Regression (QA) cleanup and stress test work to bring Resin 4.0.2 up to a production level.
• WebSocket, HMTP and JMTP support.
• JMS clustered singleton queue and clustered topics
• /resin-admin support for REST-based management tools such as nagios.
• Enhanced /resin-admin monitoring to better illustrate the server status.
• HTTP Proxy and FastCGI load balancing with failover.
• Eclipse plugin enhancements.

Resin 4.0.x is the active development branch.

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

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.

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.

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 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:

1. Upload the .war contents transactionally to the server (but not activated yet)
2. Deploy and test a "staging" version on a single machine.
3. Activate the .war for the production servers.

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

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.

The focus of Resin 4.0.1 development was the following:

• CanDI major refactor to match major changes to the JSR-299 specification.
• Servlet 3.0 early access implementation, including replacing Resin's experimental comet support with Servlet 3.0 async
• 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.

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's concurrent connections have been tested up to 10,000 simultaneous keepalive connections and 10,000 simultaneous Servlet 3.0 AsyncContext connections on Linux systems. Resin's direct support for Linux EPOLL enables this large-scale keepalive support.

The Java Injection specification has been updated considerably from Resin 4.0.0 to Resin 4.0.1. Most of the spec changes have been on the SPI side with a complete new SPI for custom configuration.

The packaging has also changed, with the main package now being javax.enterprise.inject.

The CanDI project page gives more information, including a link to a CanDI tutorial.

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.

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.

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.

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

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

• Resin 10,000
• Java Injection (JSR-299, CanDI)
• Distributed Deployment
• Distributed Caching
• Dynamic Server Deployment
• Clustered Session Refactor
• Distributed JMX
• Eclipse plugin
• Maven Jar Project Repository
• Rewrite redesign
• FastCGI support
• Security Redesign
• Management services
• JMS
• BAM updates and refactoring
• Win32 OpenSSL
• Quercus: PHP on the JVM
• PHP on Google Application Engine

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'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.

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.

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.

Resin's distributed deployment uses the git file format for transactional reliability, and uses BAM/HMTP for distributed communication.

Clustered caching is now available using the JCache API, which is a java.util.Map extension. All servers in a cluster will receive updates for cache updates.

The clustered caching uses BAM/HMTP to communicate cache updates.

Resin 4.0 now lets you add and remove servers dynamically. You'll add the new server in the /resin-admin or through JMX, and start the server normally.

Distributed sessions now use the new distributed caching capabilities to share changes across all servers in the cluster.

The internal, distributed JMX implementation now uses BAM/HMTP to communicate JMX attributes and actions.

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

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.

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

<web-app xmlns="http://caucho.com/ns/resin">
  xmlns:resin="urn:java:com.caucho.resin">

  <resin:FastCgiProxy regexp="^/fcgi" address="localhost:9000"/>
  <resin:HttpProxy regexp="^/http" address="localhost:8080"/>
  
  <resin:Dispatch regexp="(\.php|\.js|\.gif|\.png)$"/>
  <resin:Dispatch regexp="^" target="/index.php"/>
  
</web-app>

Resin now supports fast cgi as a front-end protocol, allowing it to be used with servers like nginx and IIS fastcgi support.

<resin xmlns="http://caucho.com/ns/resin"
    xmlns:resin="urn:java:com.caucho.resin">

    <cluster id="">
      <server id="">
        <resin:FastCgiPort port="9000"/>
	...
      </server>

      ...
    </cluster>
	
</resin>

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

<web-app xmlns="http://caucho.com/ns/resin">
  xmlns:resin="urn:java:com.caucho.resin">

  <resin:XmlAuthenticator>
    <user name="harry" password="..."/>
  </resin:XmlAuthenticator>

  <resin:BasicLogin/>

  <resin:Allow url-pattern="/secure/*">
    <resin:IfUserInRole role="user"/>
  </resin:Allow>
  
</web-app>

Resin's management services have been reconfigured to use CanDI style configuration.

<resin xmlns="http://caucho.com/ns/resin"
  xmlns:resin="urn:java:com.caucho.resin">

  <cluster id="app">
    <resin:DeployService/>
    <resin:JmxService/>
    <resin:LogService/>
    <resin:StatService/>
    <resin:XaLogService/>
    ...
  </cluster>

</resin>

JMS configuration now uses CanDI style configuration.

<web-app xmlns="http://caucho.com/ns/resin"
  xmlns:resin="urn:java:com.caucho.resin">

  <resin:JmsConnectionFactory/>
  <resin:MemoryQueue name="test"/>

</web-app>

Resin now uses BAM/HMTP for all internal messaging, including the distributed caching, dynamic servers, and distributed deployment.

Win32 openssl version is compiled against Shining Light's 0.9.8k

Win64 openssl version is compiled against Shining Lights 0.9.8k

Quercus continues to improve, with significant performance improvements and many compatibility bug fixes.

An GoogleQuercusServlet has been created to support Quercus on the Google Application Engine.