Fast Restartibility - Standalone Ehcache now has support for full fault tolerance using new Fast Restartability (from disk). This allows for continuous accessibility of previously cached data after a planned or unplanned shutdown.
Terracotta Managment Console for Ehcache - A new web-based monitoring and administration tool for standalone Ehcache applications. This replaces Ehcache Monitor and provides an enhanced user interface focused on ease of use in managing your Ehcache deployments.
In-memory data storage - BigMemory Go comes with 32GB of free storage capacity per JVM
Fast Search - BigMemory Go provides powerful search APIs for searching in-memory data in a predictable manner with extremely low latencies.
8308 - NPE on local transaction commit
8234 - Resolve issue with ConfigurationUtil.generateCacheManagerConfigurationText not producing nonstop element
8212 - Fix to handle a frequently empty object manager
8203 - Duplicate keys returned by method getKeys() of class Cache
EHC-976 - Search fails when copyOnRead and copyOnWrite are both set
EHC-973 - Failure while decoding key java.nio.HeapByteBuffer
EHC-962 - JavaDoc of Element.getValue() is wrong for non-Serializable values
8194 - Write Behind config for writeBatchSize set w/o writeBatching enabled to true, gives no exception/warning that it's still not a BatchProcess enabled
net.sf.ehcache.configurationResourceName is ignored
Eviction count always comes as zero
Can probably add the java.lang.Class type to the built-in ignore list
Transient attributes are not ignored in ObjectGraphWalker, causing Ehcache to not work with Groovy
Possible memory leak in xa_strict mode
Make @IgnoreSizeOf inheritable by users
SizeOfPolicy cannot be set/add if TransactionManagerLookup was previously set/add
Not release lock in SelectableConcurrentHashMap
Can probably add the java.lang.Class type to the built-in ignore list
Agent shouldn't put in System props by default
transactionalMode setting via code has no effect
Transactional cache with short TTI / TTL can provoke deadlocks
ManagementService does not check for both class type of caches "Ehcache" and "Cache" which causes an NullPointerException if you attempt to use BlockingCache
absolute memory configuration
Misleading AssertionError in DiskPersistentStorageFactory.loadIndex
Expose the Java property user.name for use in setting up the Disk Store
Use region.contains() in ReadOnlyEhcacheEntityRegionAccessStrategy
Ehcache core now compatible with Maven3
putIfAbsent does not work as intended with synchronous RMI distributed caches
NotSerializableException when Ehcache tries overflow data to disk in XA Mode
ReadWriteSerializationCopyStrategy does not use TCCL for resolving classes
NonStopCache causing application to hang when it is shutdown (normal shutdown not kill command)
Cache.replace(oldElement, newElement) with local cache and big memory throws ClassCastException
Replicated cache events on TC clustered caches may not work in all configurations
Update default timeout in rejoin
NotSerializableException when Ehcache tries overflow data to disk in XA Mode
Timestamper.next() can loop a billion times or more
Give access to attribute name within the Extractor classes in search
Pass properties when constructing attribute extractors instances
CompoundStore.putWithWriter doesn't follow contract regarding return value
Disallow a cache from being configured for overflowToOffHeap and terracottaClustered
JMX interface needs to translate InvalidConfigurationException throw by SampledCacheMBean.setCoherent(true) to plain RuntimeException
Create improved toString method on ResultImpl
Search. Caches can now be indexed and searched by key, value or attribute extracted from values.
This is a major new API and feature for Ehcache.
Transactions support rework. Introduced 'local' and 'xa' modes, renamed old 'xa' mode into 'xa_strict'.
SelfPopulatingCache will always release the lock on failure during the CacheEntryFactory.createEntry
Update slf4j to 1.6.1
Add new consistency modes - strong and eventual. Deprecated old coherent settings ("true", "false")
for Terracotta distributed caches.
Add rejoin feature for Terracotta distributed caches.
Move nonstop functionality from a decorator to ehcache-core.
Add explicit-locking API to Ehcache.
Blocking cache can create several StripedReadWriteLockSync
Introduced ElementValueComparator to make element value comparison used in replace() and remove()
atomic methods pluggable.
Additional statistics that break out missNotFound into missInMemory, missOffHeap, and
missOnDisk.
Extend Ehcache existing in-memory and on-disk concepts to include off-heap as an additional
possible location.
Add the ability for store implementations to return a store specific MBean implementation
that is exposed in the same manner as the existing Ehcache MBeans.
Restore support for the disk access stripes configuration property in the disk store
implementation.
EHC-740. Pick up "Read timed out" in RMI UnmarshalException.
Throw an InvalidConfigurationException when a cache is created from CacheConfiguration
without specifying a name.
Add support for JMX registration of ManagedCacheManagerPeerProviders.
Thanks to Eric Dalquist for this contribution.
Fix MemoryEfficientByteArrayOutputStream to return a correctly sized byte array to prevent
network/disk wastage in ehcache-server/disk stores respectively.
Added timeout to cache.getWithLoader.
Fix exception message to do with Element.getValue(). Thanks to Ken Dombeck for reporting this.
Monitoring solutions (Ganglia, Advent Manage Engine, Hyperic) typically allow a JMX property
to be polled and graphs produced, using percentages. Add basic percentages for cache statistics.
Added support for cacheDecorators in defaultCache.
Added support for cacheDecorators replacing the original cache when decorated cache has same name
as the cache. For use-cases like Hibernate where it helps to replace the original cache declared
in the config with the decorated cache. This can be used by making the CacheDecoratorFactory return
the decorated cache with same name as the cache.
Ehcache evictor not clearing objects as expected
Renamed TerracottaConfigConfiguration to TerracottaClientConfiguration.
Creating a new cache manager ready to talk to terracotta is way too verbose
The CacheWriter init method is only called when it was declared through config since
that code triggers when the CacheManager inits the cache
Support getCurrentNode and waitUntilNodeJoins in Ehcache cluster API
Added new attribute "storageStrategy" for Terracotta Clustered Caches. This attribute is optional with default
value "classic". The other allowed value is "DCV2" and only available for enterprise users.
storageStrategy=DCV2 provides far greater scale and throughput.
Cleaned up Configuration Generator, accessible using cacheManager.get[Active/Original]ConfigurationText method(s).
Can be used independently giving greater control over output format - indentation, newlines, suppressing
default values etc.
Better exception message when adding a decorated cache/already initialized cache to CacheManager
Added new attribute "concurrency" for Terracotta Clustered Caches. Its a non-negative integer that can be used
to specify the number of segments that will be used by the map underneath the Terracotta Store. Its optional
and has default value of 0 - which means will use default values based on the internal Map being used
underneath the store (based on storageStrategy).
closing a chache the WriteBehindManager attached to the queue does not by default finish flushing
Properly register MBeans for Terracotta clustered caches when they're added programmatically as the first
clustered caches for a cache manager.
Cache decorators can now be configured through config using "cacheDecoratorFactory" tag inside the "cache" tag.
Ehcache 2.1.0 JTA support with Atomikos requires Atomikos 3.6.5.
A meaningful log message, rather than an NPE is emitted if you configure RMI replication without
configuring a net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory in ehcache.xml. This is
apparently a relatively common configuration error.
Change the internal store structures to be fully coherent.
This allows for the addition of concurrent map like methods
(e.g. putIfAbsent) and also for JTA caching in unclustered
caches.
Change the ehcache-core Hibernate dependency to the newly
released 3.5.0-Final.
Change CacheLockProvider lock method to support reentrant acquires.
Add a lock state query method, and update BlockingCache accordingly.
Change caches to have statistics disabled by default.
Allow Elements in clustered caches to be serialized, and hence
enable replication of clustered caches.
Caches can now be configured to be copyOnRead and copyOnWrite, with user provided copy strategy or the default
serialization one. Configuration on the Terracotta config is now deprecated...
XA transactional Caches now automatically set copyOnRead on terracotta clustered stores properly
Actual copyOnRead and copyOnWrite implementation
Added putIfAbsent(Element), replace(Element), replace(Element, Element) and removeElement(Element) methods to Cache
Added addCacheIfAbsent method to CacheManager, implied removing races in managing Cache's and Ehcache's in
the CacheManager's implementation.
XA Transactional caches are now also supported with non clustered caches.
Fixed issue to support BTM and Atomikos TransactionManager's suspend/resume cycles
Fixed NPE when no DefaultCache is provided at CacheManager's instantiation
Updated to latest slf4j 1.5.11
RegisteredEventListeners.unregisterListener(CacheEventListener
cacheEventListener) throws java.lang.UnsupportedOperationException
Clustered Ehcache Hibernate caches are not set to minimalPut=true by default
Interleaving txn not support in EhcacheXAResource when the TM is Atomiko
Fix JTA version system
JTA prepared transaction for which keys are to be inserted (previously
absent) aren't unlocked when rolled
Fix JTA Deadlock
EhcacheXAResourceImpl.equals is only based on Cache's name
Default constructor for CacheConfiguration was removed in 2.0. Put back.
Enabled loading the Ehcache config file in EhCacheRegionFactory from an URL
Changed Store.put() to return boolean instead of void. cache.put() can be
more efficient by relying
on this return value instead of doing a separate containsKey() check for
each cache.put().
Added AbstractCacheWriter class for convenience.
Changed delete and deleteAll CacheWriter methods to take a newly introduced
CacheEntry type that contains
a key and possibly the element that belongs to it.
Added support for cluster topology event listeners.
Added support for cluster topology information retrieval to Cache.
Added distributed cache events for clustered Terracotta caches through
TerracottaCacheEventReplicationFactory and
TerracottaCacheEventReplication.
Added support for local and remote filtering for the cache event listeners.
Implemented rate limiting support for write-behind.
Made batch operation type ordering predictable, ie. writes always happen
before deletes.
Added statistics cache attribute. If set to false, statistics overhead is
avoided
giving a significant performance improvement in standalone ehcache. By
default
statistics are on.
Fixed performance regression which occurred in 1.7.0 when sampling
statistics was added.
For maximum performance statistics can now be turned off in config and
during
cache construction.
Changed meaning of maxElementsInMemory=0 for MemoryStore to be unlimited.
This puts it
in-line with DiskStore and ClusteredStore. This also means that a cache
configuration
defining no in-memory capacity limit gets a functioning but unlimited
capacity cache.
This is not expected to cause practical problems because in previous
versions, when
0 meant 0, a warning was issued and performance was halved.
Add necessary methods to make the Hibernate RegionFactory implementations
forward
compatible with the upcoming Hibernate 3.5 release.
Switch to using millisecond precision for access timestamps in unclustered
Ehcache elements.
Modified DiskStore to be configurable to use multiple RandomAccessFile
instances to read
the data file. Reduced the scope of synchronization on reading from the
DiskStore.
Blocking now allows for concurrent reads on the same key (i.e. same striped
lock).
Refactored Cache constructors to allow the use of a fluent interface instead
of a series of
constructor arguments. Existing constructors remain exactly the same for
backward compatibility.
Added support for CacheWriters with write-through and write-behind modes.
Added support for fast bulk-loading with incoherent mode when clustered with
Terracotta. Turning on
incoherent mode with cache.setCoherent(false) improves performance for bulk
loading.
New attribute for Terracotta clustered-caches, synchronousWrites=true|false
-- support for Terracotta's
Synchronous Write locking level in cache. Synchronous Write locking level
gives greater guarantees, but
comes at high cost in terms of scale/latency.
Added XA transaction, using JTA API. Configured through the
transactionalMode attribute of a cache in your
configuration xml file. Currently only supported on caches clustered using
Terracotta's serialized value mode.
Implemented correct cluster wide locking for Terracotta clustered Ehcache
Hibernate caches.
Added dynamic configuration support for Terracotta clustered and unclustered
Ehcache instances. TTI, TTL,
and maximum in-memory and on-disk capacities can be modified at runtime by
accessing and mutating the Cache
object's CacheConfiguration.
Added Hibernate 3.3+ API cache region factories supporting both singleton
and non-singleton cache managers.
The new API provides for concurrency improvements that were not possible
with the pre-3.3 provider API.
Add support for all tim-distributed-cache configuration options to the
terracotta ehcache configuration element.
Rewrite of MemoryStore to prevent bugs whereby the parallel key data
structure became inconsistent with the
underlying map, and therefore caused errors during capacity eviction.
Disabled caches now return null on get rather than returning a potential
stale value. This is important now
that caches can be disabled at runtime when they may not be empty.
Added "copyOnRead" setting for terracotta clustered caches. At a high level
this setting will return distinct
value objects upon every get() to a cache. The main driver for this feature
is to support caches that are
accessed by disparate OSGi bundles
Replaced single threaded use of StringBuffer with StringBuilder. Switched to
using
valueOf methods for creative primitive wrapper instances instead of new'ing
them.
Added a non-transient cache name field to the Statistics class so that cache
names
persist after passing through serialization.
Added the Exception causing the issue to the CacheException. The message now
includes the key,
rather than null.
Made "stopped" variable volatile in
MulticastKeepaliveHeartbeatSender/Receiver to make it thread-safe
Make ExecutorService's use custom ThreadFactory so that pool threads have
meaningful names.
Use UUID rather than RMI's UID which does not work in GAE.
Added CacheManager.clearAllStartingWith(String): void that clears all Caches
associated with the cache
manager, if the cache name matches the prefix profided
Enable cache loaders to work with Google App Engine.
Fixed Cache.toString() bug introduced in 1.7.0.
Fixed ttl bug introduced in 1.7.0. TTL or TTI values > Integer.MAX_VALUE
were incorrectly
downcast causing negative values. Most commonly, setting a TTI or TTL of
Long.MAX_VALUE
caused an exception to be thrown.
Fixed memory visiblity issues with fields in MemoryStore. Made maximumSize
and useKeySample
final as they never change. Made status and policy volatile as they change
but weren't
guaranteeing visibility.
Fixed a race that can cause an NPE when evicting with key samples during
put. This
can happen if there is a concurrent clear() that wipes the map as the
keyArray is
not updated under the same lock. This happens in tests a lot but is probably
less
common in actual user code.
Fixed a number of latent visibility bugs in the Cache class.
Fixed a number of latent visibility bugs in the Element class. Notably
updates to
the hitCount field are now coherent across multiple threads through the use
of an
AtomicLongFieldUpdater.
Fixed bug to avoid any limit on the number of caches that can be configured
for replication.
Earlier there was a limit on the number of caches that can be configured for
replication as
the heartbeat size was exceeding the MTU when the number of caches were high
and/or the caches had
long names. Fixed to break up into multiple payloads in case the heartbeat
size exceeds the MTU.
Fixed MemoryStore to use sufficient initial capacity for the internal
ConcurrentHashMap so that it
can accommodate the maximumSize of the store.
Allow Terracotta clustered caches to be added programmatically even when the
CacheManager was created
initially without any Terracotta clustered caches. e.g. Adding a terracotta
clustered cache programmatically
to the default singleton CacheManager when there is no ehcache.xml present
in the classpath.
cache.isKeyInCache(null) causes an NPE. Fixed.
Fixed an issue with disk store when an abrupt JVM termination leaves a
persistent disk store
in a corrupt state. This problem was introduced in 1.6.
In Ehcache 1.6 the web package was broken out into the ehcache-web module.
However the ShutdownListener
is useful even if you are not using web caching - you use it to shutdown a
CacheManager in a web app,
when the servlet container shuts down. For that reason it should be in core.
Putting it back.
Added null check to avoid NPE.
Fix for making ehcache work in Google App Engine runtime. JMX classes won't
be used when monitoring="off"
ehcache now becomes a composite modules which includes ehcache-core,
ehcache-terracotta
and may include other commonly used modules in the future like
ehcache-jcache.
ehcache-terracotta module, which provides seamless integration to the
Terracotta Server for
Terracotta based clustering.
Reduce iterator crossover from 100 to 5 to solve suspected CPU load issue in
small caches.
Take puts into account for recent use in the eviction algorithms. Fixes an
algorithm regression from
1.5.
Statistics reporting incorrectly in Hibernate in 1.6.2.
Replaced Mutex with higher concurrency strategy (ReadWriteLock based) for
both BlockingCache and
SelfPopulatingCache
Remove AsynchronousCommandExecutor. This is not used by anyone that I know
of and is obsolete
as j.u.c. provides a similar mechanism.
1.6.1 cannot read older versions' persistent stores. Thanks to Matt Passell
for the patch.
Fix retry serialize not working. Thanks to Vitaliy Garnashevich for the
patch.
Fix statistics counters. Change them to AtomicLong as they now need to be
thread-safe to be accurate.
Fix to 1.6 where clearOnFlush may now be false and were getting double
notification of a remove
or expiry if it happened after a flush. Thanks to both Kevin Conaway and
Jonathan Barbero.
Always close open files. Thanks to Vitaliy Garnashevich for the patch.
Iterating through ALL_CACHE_MANAGERS sometimes causes
ArrayOutOfBoundsException. Bug introduced
in 1.6. Fixed. Thanks to Chris Hyzer for reporting.
Current implementation stops after at least one loader loaded at least one
Element. This patch continues to poll other loaders if more keys left to
load. Thanks to Vitaliy Garnashevich for the patch.
Fixed ConcurrentModificationException when using DiskStore. This issue would
log an exception
and those elements waiting to be spooled would be discarded. The DiskStore
and cache would
continue to run unaffected. 1.6 issue.
Fixed regression in 1.6.0. When an Element is not Serializable, but it's key
is, then replications
via invalidate should still work as only the key needs to be Serializable.
1.6 issue.
Clarified and made consistent removeQuiet and getQuiet. Both do not update
statistics nor call
listeners.
Allow the network interface to be specified on multi-homed machines for
MulticastRMICacheManagerPeerProvider.
This can now be done by specifying hostName=<hostname or IP of network
interface> in the
properties.
The default interface is used if this is not specified as it has been in
past versions.
Improved incrementer in MemoryStore to avoid rare overwrites in the key
sampling. Thanks to
Michael Maraist for this fix. 1.6 issue.
Improve performance of memory store eviction.
Delete directories that were created with auto_created which are meant for
one time only use.
Fix consistency problem where, with very fast updates to a Cache, gets were
returning old versions.
Thanks to Marcin Sciesinski for a very clear test case which showed the
issue.
Added compatibility for Google App Engine. To get started read
http://ehcache.sourceforge.net/documentation/googleappengine.html for more
details.
Removed slf4j, which was causing ClassNotFoundException for some users.
You can still log via SL4J using the SLF4JBridgeHandler. See
{{http://www.slf4j.org/legacy.html}}
See the http://ehcache.sourceforge.net/documentation/logging.html for more
details.
Preserve \ and $ when in ehcache.xml.
Fix to an issue introduced in 1.6.0-beta5.
It was possible for the probabilistic eviction algorithm to return null,
which could cause a slow
memory leak. Fixed. If this happens on an eviction we do a further selection
via iteration
which is guaranteed not to return null.
Fix Bug in RMIAsynchronousCacheReplicator.clone introduced in the 1.6 beta
series.
UpdatingSelfPopulatingCache had not been converted to work with
non-Serializable objects. Fixed.
Fixed rare ConcurrentModificationException when calling cache.flush() to
persist to the disk store
during cache operation. cache.flush() is now asynchronous as a result.
added clearOnFlush cache parameter. It determines whether the MemoryStore
should be cleared when flush()
is called on the cache. By default, the MemoryStore is cleared. Useful is
you want to back up a cache
to the file system without clearing the MemoryStore. Thanks to Matt Passell
for the patch.
/ used to be an illegal character in ehcache cache names. However JBoss 5
uses / in its JPA cache names.
/ is now a legal character so as to interoperate with JBoss 5.
Brought back the LruMemoryStore from ehcache-1.5 and prior. This can be
switched in for LRU eviction
algorithm cache using set java -Dnet.sf.ehcache.use.classic.lru=true
By default the new, high performance MemoryStore is used for all eviction
algorithms.
Added slf4j, replacing java.util.logging. I succumbed to the logic that a
library should use an abstract
logging interface. This _may_ be replaced by configurable logging in
ehcache.xml, which will then
remove the dependency on sl4j while still permitting its and other logging
frameworks use.
Make MemoryStore eviction policies injectable.
Fix NPE on cache operations during cache.dispose();
Fix DiskStore recovery after dirty shutdown bug introduced in beta4.
Fix MemoryStore concurrency issue introduced in beta4.
Remove many uses of synchronize and replace with new concurrency techniques
available in Java 5.
A concurrent test with 70 threads doing a realistic mix of operations gets
are 92.5 times faster,
puts are 30 times faster, removes are 48 times faster, removeAlls are 80
times faster,
and keySet is 30 times faster.
Add replicatePutsViaCopy to the RMI replicator. This determines whether the
new elements are
copied to other caches (true), or whether a remove message is sent. Defaults
to true.
A replicateUpdatesViaCopy property was already there.
With these two properties, fine-grained control is available to ensure
distributed cache
coherency is maintained.
Don't automatically delete the DiskStore index on startup.
Fix documentation: missing parentheses from samples.html.
The isSerializable() method on Element was too narrowly defined. Adjusted to
allow Elements with
null values to be Serialized. This change affects DiskStore and replication.
Null objects of any class will serialize. Also recorded as 2153609.
Made the synchronous RMI replicator log exceptions as SEVERE rather than
throwing them, to make this
consistent with the asynchronous replicator. The change means that you
cannot detect that replication
has not occured to a given peer. Given that we are not transactional, this
probably does not matter.
Notifications happening on removeQuiet when they should not.
Extra logging around RMICachePeer. Add the cacheName to the FINE log output.
Added support for UTF8 file encoding of ehcache.xml. This makes it possible
to specify cache names
in non Western languages.
Updated provided scope dependency of Hibernate to 3.2.6GA to pick up a
signature change in
CacheException to Throwable.
Remove all of JSR107 JCACHE into its own module called ehcache-jcache, which
will have its own
release cycle. The jsr107cache dependency is thus no longer required.
Allow multiple replication schemes to be used within the same CacheManager.
i.e. use JMS for some
caches and RMI for others.
Add a reference to Ehcache from CacheStatistics. Request 2128129
Add FINE level LOG statement for Hibernate EhCache provider puts. This
enables puts to be debugged
with LOG statement. Request 2061030.
Removed cacheManager.getCachePeerProvider() in favour of
cacheManager.getCacheManagerPeerProvider("scheme")
where scheme is the replication scheme. Each replicator type can then call
its own scheme provider,
allowing multiple replication schemes to be used within the same
CacheManager.
Removed commons-collections. The LRUHashMap was only being used by early
versions of Terracotta
integration
and is not longer required to support Terracotta.
Removed dependency on backport concurrent. java.util.concurrency is now
used.
Removed dependency on commons-logging. Ehcache now uses java.util.logging at
the request of many users.
Java 1.5 is now the minimum version for ehcache 1.6. Java 1.4 will continue
to be supported on the
ehcache
1.5 branch. Ehcache can reduce its dependency list for the core and
therefore occupy a smaller footprint
in new applications.
Add the ability for the MBean classes to be used in remote JMX clients, in
addition to the current
mechanism which uses standard JDK types. The ehcache classpath
should be added to the client for this to work. e.g. jconsole
-J-Djava.class.path=ehcache.jar
Due to requests for more sophisticated features and end user experience with
the CacheLoader interface
the following changes have been made:
- A Cache may now have a list of CacheLoaders. If the first loader returns
null, the next in the list
is attempted until a non-null result occurs or the chain of loaders ends.
- If a loader does not load, no element is put in the cache, rather than an
element with a null value.
This is more consistent with the rest of the API anyway and has been
requested by users.
- Loaders now have a maxLoadTimeMillis property which sets the maximum
amount of time for the loader
to wait for the load.
- To support sophisticated loaders like the JMSCacheLoader, the CacheLoader
interface adds lifecycle
methods, so that it can be bound into a cache's lifecyle. Also there is a
new factory method for loaders
to bring them into line with extensions such that a back-reference to the
owning Cache is injected
at configuration time.
The upshot of these changes is that implementers of CacheLoader will need to
update their
implementations
for these changes.
The setter and getter for CacheLoader has been removed because it now a
list, not a scalar.
New registerCacheLoader and unregisterCacheLoader methods have been added
for programmatic
configuration.
The getCacheLoader method has been removed.
Cache configuration individual methods have been deprecated for several
years. In this version, the
deprecated methods are removed. Use cache.getCacheConfiguration() to get the
configuration object
and then get individual properties.
Cache statistics individual methods have been deprecated for several years.
In this version, the
deprecated methods are removed. Use cache.getStatistics() to get the
Statistics object
and then get individual statistics.
Fix loading of net.sf.ehcache.hibernate.EhCacheProvider from multiple class
loaders. The insistence
that a leading slash be at the front of the
"net.sf.ehcache.configurationResourceName" property has been
removed.
If this fix causes anyone an issue, add the "/" to the front of your path.
Updated the BlockingCache.get() JavaDoc to clarify the contract when a
RuntimeException is thrown.
Added a more meaningful LOG message when a null element is encountered from
a replication. The only
reason
that an element can be null is because a SoftRefernence has been reclaimed
by the JVM. The log message
recommends either increasing heap or setting -Xms to be the same as -Xmx as
the Sun JDK will reclaim
SoftReferences
in preference to increasing heap.
The remote debugger has had many improvements. It is now packaged in its own
tarball available from the
downloads
page, and also continues to be published as a maven module. It is not in the
core tarball so that more
focus
can be given to it.
Fixes to changes made in 1.5.0-beta1: token replacement in ehcache.xml
parsing and Cache.get() not
searching
the DiskStore.
Added JGroups Implementation. Thanks to Pierre Monestie for the patch(es)
for this. Though new to the
core distribution
JGroups replication has been in production use in a large cluster for the
last 10 months.
Applied through patches 1730405 and 1912931.
CachingFilter changed to use BufferedOutputStream rather than OutputStream.
This is a performance
improvement.
Thanks to Vitaly Baranovsky for the patch.
Removed setThreadName usage to increase performance.
JCache interface improvement. if we want preload for this cache, and we
probably don't know all
the keys at the system startup time. We may want to have new interface:
loadAll()
This will not be added to ehcache until it gets added to the JCACHE spec.
Clarified JavaDoc and behaviour so that Cache.getQuiet does not update
Element statistics but also
cache statistics.
Enhanced behaviour of diskPersistent so that it will work for MemoryStore
only caches. On shutdown
the memory store will be written to disk and on startup loaded up into
memory. But DiskStore itself
will not be used during cache operation.
The diskStore element in ehcache.xml is now optional. If all caches use only
MemoryStores, then
there is no need to worry about configuring diskStore. This will simplify
configurations particularly
where multiple CacheManagers are being used.
If one or more caches requires a DiskStore, and none is configured,
java.io.tmpdir will be used and
a warning message will be logged to encourage explicity configuration of the
diskStore path.
Thanks to Robert Watkins for suggesting this one.
By default RMI will assign a random listener port to a new Remote object
which prevents its operation
through firewalls. Added a new property remoteListenerPort to
RMICacheManagerPeerListenerFactory
to enable it to be specified.
Made ManagementService accessible from IoC containers by providing a
constructor.
Added a new system property expansion token "ehcache.disk.store.dir" to
DiskStore configuration which
can be
used to specify the DiskStore directory on the command line or in an
environment variable.
e.g. java -Dehcache.disk.store.dir=/u01/myapp/diskdir ...
Thanks to Brian Chan and others for suggesting this one.
Add the ability to specify system property tokens using ${tokenname} in
ehcache.xml which are then
replaced when the
configuration is loaded.
Updated the remote debugger with enhanced reporting and better documentation
(See Logging page in
the documentation).
The new version prints a list of caches with replication configured, prints
notifications as they
happen, and periodically prints the cache name, size and total events
received.
SimplePageCachingFilter returns same content for GET and HEAD. This one is
an edge case that can happen.
Thanks to Vitaly Baranovsky for the patch.
Change CachingFilter to use setHeader rather than addHeader which was
duplicating some headers.
Updated the JavaDoc to clarify the meaning of the constant SHORT_DELAY.
Fixed inefficient shutdown of cache when the cache is not diskPersistent.
Corrected ehcache.xsd so that minOccurs of cache can be 0. This makes
ehcache-default.xml legal.
Thanks to Andreas Sahlbach for reporting this.
Fixed Cache destroy exception where Hibernate and Spring are both shutting
down during
undeploying application.
ehcache-failsafe.xml was not being included in the maven package. Moved it
to resources so that now it
is.
JCache.getAll wraps values in Element. One place was missed in the fix for
this in 1.4.0. Now all
correct.
Fixed error in Cache.remove/Ehcache.remove JavaDoc
Update backport-concurrent version to 3.1. This version is available for all
versions of Java including
6.
Tuned a few unit tests use of Thread.sleep due to the Windows timing service
of inaccurate aperture.
Some tests that used an added 10ms to allow for Windows now allow for 20ms,
based on research published
in this bug report.
Removed one last thread renaming method. The others were removed in 1831446.
Thanks to Diogo Quintela
for pointing this out.
NPE in MulticastKeepaliveHeartbeatReceiver when accessing
processingThreadPool during startup.
RMIAsynchronousCacheReplicator flushReplicationQueue change to speed it up
and remove pausing. Thanks to
Kyle Sampson for this one.
RegisteredEventListeners is not thread-safe where listeners are being added
and removed during
operation.
Fixed. Thanks to Geoffrey Arnold for pointing this out. Also removed final
from class.
CacheStatistics causes a NPE if used for fresh caches. Fixed.
Dropped thread renaming in SelfPopulating cache. A debug feature that has
probably outlived its
usefulness.
cache.getAllWithLoader should use a loadAll method for any keys not present
in the cache rather than
loading
individually. This is a performance optimisation. Fixed.
Division by zero in RMIBootstrapCacheLoader.java where elements are non-null
but empty, which causes
bootstrap to fail, although gracefully. Fixed.
Style issue. Abuse of Exceptions. Fixed.
JCache.getAll wraps values in Element. Fixed.
Replication Thread of Default Cache not disposed. Fixed.
Add CacheLoaders to ehcache configuration and core classes.
Add CacheExceptionHandlers. The enable an exception handler to be registered
with a cache so that it is
called
on exception rather than the exception being thrown.
Add CacheExtensions. This is a generic facility which holds a reference to a
cache and is bound to the
cache lifecycle,
making possible a wide variety of extensions to behaviour.
Add a version number to the ehcache jar manifest as is the Apache
convention.
Include all required libraries in the Sourceforge tarball download.
Updated FAQ and Dependency chapters in the documentation and the Release
Notes to point out that
backport-concurrent
for Java 5 is not compatible with Java 6, but the Java 4 version is.
LfuMemoryStore did not support Non-Serializable objects.
Excessive CPU and (debug) logging when multicast send fails. Added a sleep
to reduce the log spam
when multicast is being blocked by a firewall. Continuous log messages
obscure the network configuration
issue. Thanks to Ronald Tschal for the bug report and patch.
NPE during CacheManager shutdown with persistent disk cache only where the
maxElementsOnDisk=1.
Thanks to James Shaw for the bug report.
i18n issue in the PageFragmentCachingFilter. Thanks to David Sheldon for the
bug report and fix.
ManualRMICacheManagerPeerProvider.listRemoteCachePeers lists no peers if one
node is down. The manually
configured
cluster should list those peers that are available so that the cluster can
continue until the missing
node is restored.
Where the Hibernate EhCacheProvider or SingletonEhCacheProvider is being
used with a
configurationResourceName to
load an ehcache configuration other than default, when it is not found in
the classpath, no warning or
other failure
occurs. Ehcache will instead load itself from defaults.
Added a warning message to indicate that a configurationResourceName was
specified but could not be
found.
This should simplify debugging. Thanks to Robert Watkins for raising this
issue.
RMIRegistry is now stopped if it was started by ehcache. This fixes a
classloader memory leak on
redeploy
and reload in app servers. Thanks to Stefan Fleiter for supplying a patch.
Tweak to bootstrap to check for expired elements. It will skip expired
elements rather than failing the
bootstrap.
Thanks to Stefan Fleiter for supplying a patch.
PropertyUtil.parseProperties using a JDK 1.5+ only feature. This issue was
introduced in 1.3.0-beta3.
Thanks to Ben Piper for pointing this out.
DiskStore trace message for put back ups should only log when the DiskStore
is backed up.
Thanks to Stefan Fleiter for this one.
Add the ability to specify the property separator for the properties element
in factory configurations.
This is a new attribute propertySeparator that can be used in ehcache.xml
configuration files.
Enable the DiskStore to be programmtically pluggable in the Store hierarchy.
Thanks to Matt Magoffin for the patch.
Applied minor patch to Element to allow it to be easily persisted using
mechanisms other than Java
Serialization.
Thanks to Matt Magoffin for the patch.
Problems when peer lookup fails when receiving heartbeats because heartbeat
receiving is
single-threaded. This issue
affects dirty or misconfigured networks or clusters. It hardens ehcache so
that valid peers can still
form a cluster
in the presence of Naming.lookup() problems with one or more peers. Thanks
to Daniel Weill and Fredrik
Bertilson for
reporting this and Daniel for supplying a patch. The patch changes the
heartbeat receiving
implementation to be
multi-threaded
so that one bad peer cannot bring the others down.
Ehcache does asynchronous puts to the DiskStore. In previous version the
amount of memory that could be
used for spool
buffering was
unlimited. In very high load situations with limited memory this could cause
OutOfMemory erros. This
version introduces a
diskSpoolBufferSizeMB
configured per cache with a default of 30MB. Set this value to control the
maximum amount of memory each
cache DiskStore
spool can consume.
The default of 30MB should work well for backward compatibility. If you
notice your DiskStore
performance is affected
negatively,
increase diskSpoolBufferSizeMB.
Fix issue reported by Fredrik Bertilsson regarding peers entering and
leaving a cluster, where the
reentered peer would
never get
updates.
Fixed RMICachePeer.getElements so that it does not allow null elements.
DiskStore SpoolThread is too slow under Java 1.6. The Spooling Thread was
set to 2, on a scale of 1 to
10
from lowest to highest priority. Under JDK 1.6, this setting did not
allocate enough CPU to enable the
spool to be cleared in a given situation, whereas under JDK1.5 it did. This
seems to be a bug in JDK6.
The priority is now set to Thread.NORMAL_PRIORITY, which is 5.
Distributed cache - flushing replicationQueue on dispose. We should flush
the replication queue rather
than
clear it on dispose.
Fix clone problem introduced in 1.3-beta. This affects caches created from
the default cache.
Thanks to Erik Voorbraak for reporting this.
Add note to sample ehcache.xml and documentation about the reserved cache
name "default".
The shutdown hook is now turned off by default. Set the system property
net.sf.ehcache.enableShutdownHook=true to turn it
on.
Document known issue with Tomcat. The presence of multiple <Host>
entries in Tomcat's server.xml
prevents
replication from occuring. Thanks to David Patton for reporting this.
Make clear in the JavaDoc documentation in Cache that RemoteCacheException
can be thrown by calls to
put, remove and removeAll when the cache replication policy is synchronous
and a remote peer is
unavailable.
Thanks to Christopher G. Stach II for reporting this issue.
Added a net.sf.ehcache.jcache package, which is an implementation of JSR107,
backed by ehcache.
Added a net.sf.ehcache.management package, which contains full JMX
instrumentation for ehcache.
Statistics Variables Need to be Longs. Changed internal representation to
long in Cache, kept the
direct getters for backwards compatible and changed the new Statistics class
to be long based. Use
getStatistics() to access the longs with out loss of precision.
Reapplied. Somehow this got lost from 1.2.4.
Filter was rethrowing IOException as ServletException. The spec is clear
that IOException is thrown
as well. Catching these and rethrowing them as ServletException causes these
IllegalStateException
in Glassfish.
JBoss, Spring and some other applications have shutdown hooks. A race
condition existed in
CacheManager#shutdown() such that multiple shutdown hook threads could
attempt to shutdown
the CacheManager at the same time. Added class synchronization to prevent
this and also
added a check for the system property
net.sf.ehcache.disableShutdownHook=true which will disable
addition of the shutdown hook. Reported by various people.
Note: In ehcache-1.3-beta2 and higher the shutdown hook is off by default.
The above property has
no effect. Set the system property net.sf.ehcache.enableShutdownHook=true to
enable it.
Element#equals(Object) causes ClassCastException when the comparison object
is not an Element. Fixed.
GzipFilter corrupts UTF-8 encoded non-Latin characters. Fixed. Thanks to
Matt Raible and Konstantin
Kolinko for the bug report and Kolodin for the patch. This issue also
affected the CachingFilter.
Fix bug in RMIBootstrapCacheLoader.doLoad. If the first element in the
remote cache is null, no
bootstrapping
will take place. Fixed. Thanks to Ben Piper for reporting this one and the
fix.
Fix issue reported by Fredrik Bertilsson regarding peers entering and
leaving a cluster, where the
reentered peer would
never get
updates.
Fix bug for the combination of Automatic Peer Discovery and synchronous
bootstrapping.
Removed the JNDI manual listener and peer provider. This was proving
difficult to maintain. Custom
listeners and providers are pluggable and can be added as an extension to
ehcache.
Consolidate shutdown hooks to one on each CacheManager instance.
Dropped support for JDK1.3. Resulting changes are proper chained exceptions,
and no longer requiring commons-collections. This enables some
simplifications
in the code base and eases maintenance.
Added a maxElementsOnDiskStore attribute to cache. This lets disk stores be
bounded. ehcacheLFU eviction is used to decide which element to evict.
Combined the DiskStore's expiry and spool threads. They were competing for
the
same locks anyway. This reduces the maximum number of threads used from 2 to
1 per
DiskStorwe.
Enable the timeToLive to be set on the cacheManagerPeerProviderFactory. This
enables
the spread of multicast packets to be controlled from a single host to the
Internet.
The default is 1, which is the same as the Java default so the default
behavior will not
change for existing users.
Fix typo in lock timeout log message in BlockingCache. Thanks to Matt
Magoffin
for reporting this bug.
Fix issue where it is not possible to specify a DiskStore path consistently
on all operating systems. This is a workaround to a JDK bug. Always create
paths like "java.io.tmpdir/cache". Any trailing characters to java.io.tmpdir
added for windows and solaris will be removed and placed with a single file
separator.
Fixed NullPointerException on Cache.evictExpiredElements() and added some
other NPE
guards to Cache.
Synchronous bootstrap and manual peer discovery combination does not work
because
the first cache to start always fails. This is normal and the CacheManager
should
cope with it. Added a catch and log a message when this happens. Thanks to
Patrick
Galley for the bug report.
ehcache.xsd diskStore path defined as xs:NCName
Fix documentation error: Ehcache provider package inconsistent
Fixed NPE when both DiskStore path is not configured and DiskStorePath is
not being used.
Thanks to mdillon for the patch. This was also reported under the above bug
number.
CachingFilter and its subclasses now work when upstream filters or servlets
return
404 or 302, 301.
Fixed rare ConcurrentModificationException in getBoundCachePeers. Thanks to
Tony Voss
Harden heartbeat sender for IOExceptions and large peer sizes. Thanks to
Tony Voss
for the patch.
Reduce network utilisation for distributed caching through the optimisation
of only
doing a Naming.lookup(url) when the url has not been seen before.
Various fixes to web package to make filters work on Sun Application Server
9 and Tomcat
in addition to Orion. Add support for errors and redirects passing through
filters.
Multiple multicast packets sends multiple heartbeats
Infinite recursion in BlockingCache.getKeysNoDuplicateCheck
Statistics Variables Need to be Longs. Changed internal representation to
long in Cache, kept the
direct getters for backwards compatible and changed the new Statistics class
to be long based. Use
getStatistics() to access the longs with out loss of precision.
Cache.remove doesn't fire listeners if element didn't exist. This stopped
cluster
removes from working where the local cache does not have the element cached.
Thanks
to Elijah Epifanov for reporting this one and arguing the case for this
behaviour
Allow references to ehcache.xsd in ehcache XML files. All of the ehcache.xml
files
have had the schema reference added. This allows easy validation of
ehcache.xml
configuration files using tools like Eclipse and IntelliJ. Thanks to Gabriel
Klein
for suggesting this.
Added a new property asynchronousReplicationIntervalMillis to the
RMICacheReplicator factory
configuration to control the interval at which it runs. The default is
1000ms,
which
is the value it was hardcoded too in earlier versions.
Added a new notifyRemoveAll cache event notification as requested by users.
Called during Ehcache#removeAll() to
indicate that the all elements have been removed from the cache in a bulk
operation. The usual
notifyElementRemoved is not called.
This notification exists because clearing a cache is a special case. It is
often
not practical to serially process notifications where potentially millions
of
elements
have been bulk deleted.
Added a new notifyElementEvicted cache event notification as requested by
users.
Called immediately after an element is evicted from the cache. Evicted in
this
sense
means evicted from one store and not moved to another, so that it exists
nowhere in the local cache. In a sense the Element has been removed
from the cache, but it is different,
thus the separate notification. The usual notifyElementRemoved is not
called.
Asynchronous replication / soft references.
There is a trade off between OutOfMemory risk and replication correctness.
Change the RMIAsynchronousCacheReplicator so that Elements are
SoftReference,
not
all EventMessages. The result is that put and update via copy may be
SoftReference
collected, but remove and update via remove will always go through.
Change Cache#getQuiet so that cache statistics are not updated. This is a
sensible
API change and probably always should have worked this way.
Open up some classes by removing final keyword and changing the constructors
to
public.
Fix isssue where a distributed cache can take up to a minute to shutdown.
This
issue
affected web container and application server shutdowns.
The fix is to unbind RMICachePeers before unexporting them. Thanks to
Lennard
Fuller
and Peter Chiang for finding and fixing this hard one.
Fixed a few broken links and inconsistencies in the documentation.
Bad dependency scopes in Maven2 POM. Most dependencies are required only at
test time.
Changed the pom to reflect this.
Synchronous replicators in a cluster can deadlock trying to replicate to
each
other.
The deadlock gets resolved by a SocketTimeoutException depending on what you
set it
too. Reduce synchronization around gets, puts and removes so that listener
notification
is not synchronized, which resolves this problem.
Fixed a bug where in BlockingCache and SelfPopulatingCache where
setTimeoutMillis
was set to a non zero value.
Large TTL values cause expire time to be incorrect in Element. Changed
ONE_SECOND from
an int to a long which fixes the issue.
Added a ShutdownListener which implements ServletContextListener for
shutting
down all CacheManagers in a web application.
If you put an Element with overridden TTL and TTI values and then replace it
with an Element with defaults, the new Element lives forever. putQuiet is
not
affected by this bug. Thanks to Pete at Goodtech for finding this one.
Note that a symptom of this bug for caches that overflow to disk is an
endlessly
growing .data file for the Cache.
Reduce the memory used by flushSpool() in DiskStore.
See http://gregluck.com/blog/archives/2006/07/tuning_memory_u.html for
details.
Cache names with slashes cause problems. Tightened the validation code
around
setting a cache
name. Now throw IllegalArgumentException if a cache name is null or contains
'/'. Thanks to Daniel
Wiell for repoting this one and suggesting the fix.
Loading an element from the disk store fails in some circumstances due to
classloading
issues. This issue was created by a patch to fix 1324221 back in October
2005.
Resolved
by trying the new way and then, if a ClassNotFoundException is thrown, doing
it
the old way.
CachingFilter should not change Thread name. Now sets it back to the
original
when done.
Change Blocking cache to use a lock striping technique for its Mutexes. This
limits the number
of Mutexes to 100, rather than a number equalling the number of keys, while
preserving excellent
liveness and safety. Thanks to Olaf Krische for reporting this and Brian
Goetz
for assisting with
a solution.
Change BlockingCache and SelfPopulatingCache to act as decorators for
Ehcache.
Remove now redundant
BlockingCacheManager and SelfPopulatingCacheManager. Change signatures of
these
caches from Serializable
to Object. This change is not backward compatible but no libraries use
these,
so developers can change
over on their own projects.
This was reported by Victor Volle and is a duplicate of 1492900. Fixed.
Changing all classloading to the context classloader is sometimes
inconvenient.
Fallback to
ClassLoaderUtil.class.getClassLoader() if
Thread.currentThread().getContextClassLoader()
fails. Thanks to Robert Watkins for reporting this one.
Debug messages generate excess String objects. Added logging level guards
around about 6 debug log statements.
Thanks to Derek Hulley for pointing this one out.
Harden all ehcache threads so that RuntimeExceptions and Errors do not stop
them. This change, on its own, has been
backported to a separate release, ehcache-1.2.0_01.
Change spooling mechanism to use less memory, so as to avoid memory spikes.
Added the constructs package which was previously a separate module. The
constructs package adds
valuable functionality and given that the 1.2 jar size is large, can be
added
with only a small
increase in jar size.
Allow zeroconf of RMICacheManagerPeerListenerFactory. A configuration
<cacheManagerPeerListenerFactory
class="net.sf.ehcache.distribution.RMICacheManagerPeerListenerFactory"/>
will now work. The listener port will be automatically assigned a free port.
New SingletonEhCacheProvider for use by Hibernate in situations where code
has
been written which relies
on the singleton behaviour of ehcache-1.1 and earlier. Most code bases using
Hibernate should not
require this.
Allow cacheEventListenerFactory elements to be added to defaultCache in
ehcache.xml. This allows
caches created with CacheManager.addCache(String cacheName) to receive
events.
This can be used for
example to set default replication settings in defaultCache.
To complement full support foe default cache (above), added support for
programmatic addition of caches
which include CacheReplicators. Also support for removal of these caches
with
CacheManager.remove(String cacheName).
Andy McNutt's JNDI-based manual RMI replication added. See ehcache.xml
example
for how to use.
Support tomcat 5.5 for the servlet filters. Tomcat integration testing, in
addition to the Orion one, is also
added to the full JUnit test process. Tomcat relies on Servlet 2.4
dispatcher
INCLUDE and FORWARD directives
for page fragment caching.
Support runtime setting of individual Element time to lives, time to idles
and
eternal overrides.
If an override is set, the Element expiry ignores the Cache default.
Add a cache bootstrap mechanism. This is used to populate a cache when it is
first initialized. An
abstract factory, BootstrapCacheLoaderFactory has been defined along with an
interface BootstrapCacheLoader.
The initial concrete implementations are for RMI, so that a new cache
entering
a cluster gets bootstrapped
from a randomly chosen peer.
Allow CacheManager instances to use the same ehcache.xml configuration.
Automatically resolve conflicts
for DiskStore and CacheManagerPeerListener. Log a warning that the conflict
existed and what was done to
resolve it along with a suggestion to either use ehcache in singleton mode
or
specify separate ehcache.xml
configurations for each CacheManager instance.
Theoretically possible NPE if a MulticastRMICacheManagerPeerProvider is
started
and then stopped
before a multicast socket connection can be established. Added guard for
NPE.
Thanks to Roman Kurmanowytsch
for reporting the issue and a fix.
Add shutdown hook to RMICacheManagerPeerListener so that, even if
CacheManager.shutdown() is not called,
processes still exit cleanly. This is a bug rather than a feature request
because Cache has a shutdown
hook to always cleanly shut down disk store, and ehcache should be
consistent
in supporting shutdown hooks.
In GzipFilter and CachingFilter Gzipping an empty response body creates 20
byte
responses. Fixed so that
this situation is detected and a zero bytes gzipped body, with a content
length
also of 0 is returned. Can
occur in 204 and 304 responses.
Changed localhost lookup to a static in Cache, to avoid a potential
bottleneck
when creating and destroying
large numbers of caches rapidly. Thanks to Derek Hully for the bug report
and
suggested fix.
Changing the API to Object from Serializable breaks projects. Leave the
existing Serializable
API in place and add new constructors and methods for Object. Add
getObjectValue and getObjectKey to
Element.
Closing Cache does not remove reference from DiskStore, preventing Garbage
Collection of DiskStore and
Cache
on dispose of a cache. Fixed to set Cache reference to null on dispose.
Thanks
to Felix Meschberger for
the patch.
Closing Cache does not remove shutdown hook, preventing Garbage Collection
of a
Cache with a persistent
DiskStore on dispose of a cache. Fixed to remove the shutdown thread after
dispose.
Thanks to Felix Meschberger for the patch.
License updated to Apache 2.0.
Following many requests, ehcache no longer requires that Elements contain
Serializable keys and values.
Ehcache will gracefully degrade for those operations which require
Serialization. In particular the
MemoryStore and event listeners can be used with Non Serializable elements.
WARNING error messages are
logged when an operation cannot be completed because the key or value is not
Serializable.
Feature Request 1458049 Wrap original exceptions during configuration.
Added an intial cause Throwable field to CacheException to facilitate easier
reporting without
breaking pre JDK1.4 compatibility.
Removed the old Hibernate plugin from the code base. It has been deprecated
since the beginning of the
1.2 beta series. The plugin is being actively maintained in the
Hibernate project. Any project still using net.sf.ehcache.hibernate.Plugin
should change their
Hibernate configurations to org.hibernate.cache.EHCacheProvider.
Feature Request 1081071. Added the ability to specify subdirectories under
System Property paths. e.g.
java.io.tmpdir/one
Feature Request 1025706. Added the ability to specify a system property,
net.sf.ehcache.disabled=true,
to
easily disable ehcache. A disabled cache works fully but discards and
Elements
added to it.
Add protections to the DiskStore spoolThread against programming errors in
Elements that can cause it to
die.
Secondly, if it does die, disable adding elements to the DiskStore and log
an
error, so as to gracefully
degrade.
flush() was using up to double the memory used by a MemoryStore during
flush()
which could cause an
OutOfMemory error on shutdown if memory was constrained. flush no longer
causes
any memory spike.
Thanks to Sergey Nekoval for reporting the bug.
Introduced new caching policies in addition to the standard LRU. FIFO and
LFU
were added. LRU remains
the default unless explicitly set in each cache's configuration. Thanks to
Surya Suravarapu for working
with me on these. The documentation has a new section on caching policies
and
when to use what.
Introduced CacheManagerEventListener and CacheEventListener interfaces and
default implementations.
These can be configured in ehcache.xml or set programmatically. Thanks to
steve
at jofti dot com for
help with the specification for these.
After requests from Jo Walnes, Paul Hammant and others, I have added normal
instance constructers to
CacheManager which do not act as singletons. The factory singleton methods
remain for backward
compatibility. CacheManager can now be constructed with a Configuration
object
programmatically.
Since version 1.1, ehcache has had a persistent diskStore, which makes it
suitable for storing
application state. Added a flush method so that, if the cache is
diskPersistent, it can be
programmatically flushed, in addition to the automatic flush which happens
at
shutdown.
Pluggable Distributed Caching. The default implementation supports cache
discovery via multicast or
manual configuration. Updates are delivered asynchronously or synchronously
via
custom RMI connections.
Additional discovery or delivery schemes can be plugged in by third parties.
DiskStore is now up to 12 times faster in certain operations and much more
scalable.
Significant (up to 7 fold) DiskStore performance increases, after
introduction
of finer grained
threading. Thanks to Robert Watkins for reporting on the performance limits.
Clover test coverage raised to 86%.
Feature Request 431481 Distributed: The ability to notify cache event
listeners
excluding
CacheReplicators
Feature Request 1431393 Events from remote in distributed cache should be
received by any non
CacheReplicator listeners
Patch 1158788. Fix for dependencies list... MemoryStore.java to remove
Apache
commons-collections for
JDK1.4
users
change default configuration to use context classloader
Fix for DiskStore to deserialize using
Thread.currentThread().getContextClassLoader()
CacheManager.shutdown now uses a Class rather than an instance lock.
Configurator gets a file not found when files contain spaces.
DiskStore degrades under load.
Change classloader to Thread.currentThread().getContextClassLoader() for
ehache.xml.
DiskStore data file is not deleted when index is corrupt.
JavaDoc documentation fix for element.getLastAccessTime returns 0 for
element
just created
Documentation should advise using the Hibernate supplied plugin rather than
the
older one in
ehcache which is now deprecated.
Fix bug introduced in 1.2 beta series. Removed Boolean.parseBoolean and
java.util.Queue which were
introduced
in the JDK1.5 API to preserve backward compatibility.
Fix bug introduced in 1.2 beta series. Changed ant script to avoid compiling
with clover in dists
Fix bug introduced in 1.2 beta series. Cannot load configuration from jar
(or
any non-file URL).
Fix bug introduced in 1.2 beta series. NPE on
RMICacheManagerPeerProviderFactory when rmiUrls not
specified. Now throws a meaningful CacheException.
Fix bug introduced in 1.2 beta series. Deadlock on deserialization of a
cache
entry. Thanks to Felix
Meschberger
for reporting the bug and uploading a patch.
Fix bug introduced in 1.2 beta series. Caches created with
Cache.addCache(String) share a
RegisteredEventListeners instance.
Thanks to Olaf Ontaine for for reporting the bug and showing how it happens.
Fix bug introduced in 1.2 beta series. RMIAsynchronousCacheReplicator
mishandling non-copy updates.
Thanks to Randy Puro for a patch.
Split out the entire constructs package. These are now in a new subproject:
ehcache-constructs, which
has been released.
See http://ehcache.org/ehcache-constructs for more details.
removed the dependency on Doug Lea's concurrency library.
Add new documentation on cache configuration and hibernate performance
tuning.
Extra check to make sure that we always close persistent disk store's
FileInputStream in the
rare case where the ObjectInputStream is null.
Added SelfPopulatingCacheManager
Added a new diskExpiryThreadIntervalSeconds configuration option to
ehcache.xml, to allow
tuning of the expiry thread per cache.
Added a new diskPersistent feature and configuration option. diskPersistent
makes disk stores
persistent between CacheManager and JVM restarts. It enables very long held
caches to be configured,
useful
for very expensive cache entries that are long lives, such as mapping
geocodes.
Expiry Thread now has a default time of 2 minutes, not 25.
Expiry Thread now dies immediately on DiskStore disposal.
cache.calculateInMemorySize() now returns a non-zero value
Bug 1025130 - Null Pointer Exception when no default cache configured. Now
we
throw a CacheException
with a
meaningful message.
Bug 1025128 IBM Websphere alway requires commons-collection.jar, even though
it
is never used. Updated
requirements
to note this.
Patch 1030960. JDK1.4 and higher now chain exception thrown from
SelfPopulatingCache.
1033061 Fix to Thread naming in SelfPopulatingCache so that the old name is
always put back.
1003659 build script unfriendly to IDE: IDE builds should now work.
ehcache.xml cache definitions can now omit timeToIdle and/or timeToLive,
which
are now optional
attributes.
This will make cache config easier to read for eternal caches.
Either omitting the attributes or setting them to 0 causes them not to be
considered when calculating
expiry.
Earlier versions of ehcache would have immediately expired all elements if
either attribute was set to
0,
so this change should not break any existing code.
Added getQuiet and putQuiet methods to Cache. These methods are the same as
get
and put
but do not affect statistics.
Implemented an Element clone method.
Added calculateInMemorySize() method to Cache to measure the approximate
size
of a cache's
memory footprint.
Increased Clover test coverage to above 80%.
Added many new tests for idle expiry.
Added tests for the new constructs package. These tests demonstrate
concurrency
performance
differences between blocking cache designs based on notify/notifyAll and
Doug
Lea's concurrency package.
Test new xml format scenarios for eternal, time to idle and time to live
Started adding performance tests to ensure there are no regressions over
time.
Added a new constructs package. There are blocking, self populating and self
populating collections
caches.
These are all pull-through caches. They are useful where the cost of
creating
an entry is high.
Details follow:
SelfPopulatingCache - a read-through cache. A cache that populates elements as they are requested
without requiring the caller to know how the entries are populated. It also enables refreshes
of cache entries without blocking reads on the same entries.
SelfPopulatingCollectionsCache - a SelfPopulatingCache that adds threading safety where it is known
in advance that all entries will be collections.
The package is useful for, inter alia, :
- Web Page caches
- Search Engine caches
See the tests for examples of how to use this package.
This package requires Doug Lea's concurrency library. A copy is provided in the tools directory
when you check out the project by SVN. Or, you can get it from http://gee.cs.oswego.edu/dl/cpj/
Note that if you are not using the constructs package, you do not need the concurrency library.
]]>
JavaDoc fixups
Fixed time to idle which was not expiring elements after the idle time had
expired. This feature did
not seem to be getting used. It is now useable. Fixed the test which was
also
broken
Fixed bugs with getSize and getKeys, which were not checking for duplicate
keys
between
the memory and disk stores.
Investigated a Hibernate SessionFactory bug and clarified it was not a
Hibernate bug. Added test.
Investigated a cache size possible bug and clarified it is not in EHCache.
Added test.
Added Clover test coverage reporting. Clover instrumentation is not included
in
release jars.
Updated Hibernate testing to version 2.1.1
Modified the Apache license at the request of the Apache Cocoon project.
Fixed a very rare null pointer exception, when retrieving a cache entry.
Cache Configuration
Fixed null pointer exception where the disk store path was not specified
when
use disk store is set to
false
JDK1.3 Compatibility Replaced JDK1.4 Exception constructors with simple
message
constructors compatible
with JDK1.2 and 1.3
Problem with Element expiry
Fixed bug where expiry checking on get was calling remove with the element
rather than the key.
Expire thread should not run if the cache is not active
Changed the expire thread to while(active)
Expiry thread unnecessarily being created for eternal caches
Skipped creating the expiry thread if caches are eternal.
Remove SoftReferences
SoftReferences for cache element values has been replaced with standard
references.
The JDK 1.4.2 JVM was found to remove SoftReferences in normal operation,
rather than
the expected behaviour of use only to avoid memory exhaustion. Caches will
now
behave deterministically. Element values will only be removed when the
element
is
garbage collected.
Hibernate Cache Provider.
Fixed bug where incompatible timestamps were generated
Time to Idle" documentation bug.
Fixed documentation bug in ehcache.xml and ehcache-failsafe.xml where "Time
to
Live" was
incorrectly referred to as "Time to Idle"
Changed from JDK1.4 Logging to Commons Logging. This is to permit JDK1.2 and
JDK1.3 to use EHCache.
Added Apache Commons Collections LRUMap as an alternative backing Map for
the
MemoryStore. The
java.util.LinkedHashMap has been retained and is used automatically for
JDK1.4
and higher.
Added LICENSE.txt to the jar in the distribution
Don't create a Disk Store when overflowToDisk="false" is set in ehcache.xml
toString() methods now report on all fields
Fixed documentation bug in ehcache.xml and ehcache-failsafe.xml where "Time
to
Live" was
incorrectly referred to as "Time to Idle"
Initial version, originally based on a fork from JCS plus donated patches.