Hazelcast Changelog

What's new in Hazelcast 3.6.3

Jun 27, 2016
  • Fixed issues:
  • MapStatisticsAwareService should obtain the map names from proxy registry. [8209]
  • Cache should not expire the entities when Duration value is set to 0. [8148], [8206]
  • Collection querying in Portables. [8172]
  • Type extraction by the method extractedMultiResult should be fixed when the extraction result is null. [8134]
  • Expiration time for the map entries should be calculated based on their latest update times. [8111], [8113]
  • Support for the usage of IAM role's defaults should be added. [8100]
  • Binary property for MultiMap should be added to XmlConfigBuilder. [8094]
  • EC2 auto-discovery in China throws an exception due to a bug in host header handling mechanism. [8073]
  • The method Cluster.shutdown() ignores lifecycle listeners. [8070]
  • Resource adapters should not cast to implementation when using a container to get a connection. [8019]
  • Unnecessary deserialization step during the execution of put operations should be removed. [8018]
  • A URL text with spaces should not be transformed into a URI. [8016]
  • Unnecessary deserialization step in the replicated map data structure should be removed. [8014]
  • When using InstanceOfPredicate, the method toObject at the server side causes NullPointerException, since the class loader is not set and it is null. Default class loader should be used if it is not set by the configuration to avoid the exception. [7977]
  • There may be cases when the server may return a list of entries larger than the requested page size. In this case the client should not put any anchor into the list that is on a page greater than the requested page. [7976]
  • When a remote invocation waits indefinitely on the internal executor, a deadlock may occur since its response would use the same executor and since the invocation monitor runs on the same executor. [7944]
  • Already published messages should be retrieved after StaleSequenceException occurs when ReliableMessageListener is registered at the client side. [7928]
  • The case of response being equal to null in the class ClientDelegatingFuture should be handled. [7901]
  • Detection of JCache should be improved. Currently Hazelcast checks if the class javax.cache.Caching is available and, if so, Hazelcast creates the JCache service and configures the client protocol messages. However, some older snapshots of JCache JARs have the Caching class available, but other classes are missing. This causes Class not found exceptions when members are started. [7899]
  • When connection gets an exception from the socket and the method destroyConnection is called before connection is authenticated, the client does not have an endpoint and it is not in the map of connections. Hence, the connection cannot be closed. [7866]
  • Upon subsequent destroy and create operations of IMap, there can be more than one map container referenced by different record stores at the same time. Therefore, indexes can be created in an unexpected map container and this can lead to return less than expected number of results when IMap is queried. [7838]
  • After the client is shut down, there should be no invocations left. The method assert() of ClientInvocationServiceSupport fails. [7836]
  • Enhancements:
  • Phone home should include environment information, such as the operating system name, version and kernel architecture. [7970]
  • Exceptions, which are thrown when the method isMemberSafe() is called, should go into finest level. When there are topology changes some exceptions are expected. The method getFutureResult() should log exceptions as finest(), not warn(). [7904]
  • Protocol version should be 1 instead of 0. It was set as 0 for the response messages. [7900]

New in Hazelcast 3.6 (Jan 29, 2016)

  • NEW FEATURES:
  • High-Density Memory Store for Hazelcast Map: With this release, Hazelcast Map data structure is now equipped with the High-Density Memory Store, previously implemented for Hazelcast JCache. Please refer to the Setting In Memory Format section.
  • Discovery Service Provider Interface (Discovery SPI): You can use this SPI to discover Hazelcast instances on cloud environments provided by jclouds, Kubernetes and many more. The existing discovery mechanisms that Hazelcast provides (Multicast, TCP/IP and Amazon EC2) have been re-implemented on top of this new Discovery SPI. Please refer to the Discovery SPI section.
  • Client Protocol: This feature presents the Hazelcast's new open binary client protocol. Please refer to Open Binary Client Protocol Documentation.
  • Client Cross Version Compatibility: Now you can upgrade your Hazelcast clients independently from servers and other clients. Please refer to Open Binary Client Protocol Documentation.
  • Support for cloud providers through jclouds: Hazelcast now supports deployments on all the well-known cloud providers through the jclouds open source library. Please refer to the Discovering Members with jclouds section.
  • Hot Restart Persistence: This new feature provides fast restarting of the Hazelcast clusters. This is achieved by storing the state of the cluster members to the disk. Please refer to the Hot Restart Persistence section for more details.
  • Ringbuffer and Reliable Topic in Hazelcast Clients: The data structures Ringbuffer and Reliable Topic recently introduced by Hazelcast (with the release 3.5) are now implemented for Hazelcast Java Client. Ringbuffer has also been implemented for .NET Client.
  • Cluster Quorum for Hazelcast JCache: Cluster Quorum checks are now provided for Hazelcast JCache implementations, too. Please refer to the Defining a Cluster Quorum section to refresh and to the ICache Configuration section to learn configuring it for JCache.
  • Split Brain Syndrome handler for Hazelcast JCache: Now Split Brain Syndrome is handled in JCache as it is taken care in Hazelcast Map. Please refer to the JCache Split-Brain section.
  • Partition Lost Listener for Hazelcast JCache: You can listen to partition lost events fired in your Hazelcast JCache implementation. Please refer to the ICache Configuration section.
  • Hazelcast Docker image: Now you can run Hazelcast using our image in the Docker platform. Please refer to Deploying using Docker.
  • Lite Members: With the re-introduction of Hazelcast Lite Members (it was removed starting with Hazelcast 3.0 release), you are able to specify certain members in your cluster so that they do not store data. You can use these lite members mostly for your task executions and listener registrations. Please refer to Enabling Lite Members.
  • Querying in collections and arrays: Hazelcast is now able to query and index attributes of objects stored in a collection or array. Please refer to the Querying in collections section.
  • Custom attributes extraction: It is now possible to extract a value of an object's attribute using a custom extractor class. Please refer to the Custom attributes.
  • Acquiring locks with a lease time: Now, you can try to acquire locks with a lease time. Please refer to the the comment for the method tryLock() in ILock code.
  • Monitoring the WAN replication: You can now monitor the state of your WAN replications using the Hazelcast Management Center. Please refer to the Monitoring WAN Replication section.
  • ENHANCEMENTS:
  • Replicated Map improvements: The implementation of Hazelcast replicated maps has been revisited. Please especially refer to the Considerations for Replicated Map section.
  • Management Center improvements: Alerting mechanism added. Please refer to the Management Center section.
  • Paging Predicate improvements: With the performed improvements, now random page accessing is supported. Please refer to the Filtering with Paging Predicates section.
  • Rule based query optimizations: This improvement introduces a query optimizer based on static rewriting rules. The optimizer treats predicates as immutable and returns a modified copy when the optimized one is found. Please refer to the hazelcast.query.optimizer.type property definition in the System Properties section.
  • WAN replication improvements: With the improvements performed on Hazelcast's WAN replication feature, you can now monitor WAN replication events for each data structure and WAN replication now supports different acknowledge types for each target cluster group. Please refer to the WAN Replication Event Filtering API section and WAN Replication Acknowledge Types section for more information.
  • Improvements on Hazelcast's OSGI support: With this improvement, Hazelcast bundles provide OSGI services so that the users can manage (create, access, shutdown) the Hazelcast instances through this service on OSGI environments. Having the hazelcast.osgi.start property enabled, when an Hazelcast OSGI service is activated, a default Hazelcast instance is created automatically. These instances can be served as an OSGI service to be accessed by other bundles. Registering the created Hazelcast instances behavior is enabled by default and can be disabled using the hazelcast.osgi.register.disabled property. Each Hazelcast bundle provides a different OSGI service and their instances can be grouped (clustered) together to prevent possible compatibility issues between different Hazelcast versions/bundles. This grouping behavior is enabled by default and can be disabled using the hazelcast.osgi.grouping.disabled property. Hazelcast OSGI service's lifecycle (and also the owned/created instances' lifecycles) are the same as the owner Hazelcast bundles. When the bundle is stopped (deactivated), owned service and Hazelcast instances are also deactivated/shutdown and deregistered automatically. Then, when the bundle is re-activated, its service is registered again. In addition, the Hazelcast Enterprise JAR file is also an OSGI bundle like the Hazelcast OSS JAR file.
  • The following are the other improvements performed to solve the enhancement issues opened by the Hazelcast customers/team:
  • Approximate max-size calculation should be removed for IMap eviction. [6463]
  • SpringAwareWebFilter should have a constructor which takes properties as arguments. [6438]
  • Client side and server side cache proxies handle putAll operation one by one. This is not efficient. Records for this operation should be grouped as per their partitions and should be sent and processed in batches. [6367]
  • Not requested events should not be sent to MapListener [6349]
  • Inconsistent and potentially buggy design in BasicCompletableFuture. [6080]
  • Starting with "hazelcast-wm 3.3", OSGI Manifest Spring package imports should be optional. [6072]
  • The new client determines the partition ID for every invocation for data structures like queue and list where the partition ID is static. There is no need for this behavior. It should calculate the partition ID for once when the proxy is created and continue to re-use it. [5848]
  • Map.Entry supplied to Entry Processor is not Serializable any more. [5611]
  • The configuration file minimal-json with the provided scope is not picked up by the shade plugin. [5543]
  • In Spring configuration, when a boolean property is injected for hazelcast bean (

New in Hazelcast 3.6 Early Access (Oct 24, 2015)

  • NEW FEATURES:
  • High-Density Memory Store for Hazelcast Map: With this release, Hazelcast Map data structure is now equipped with the High-Density Memory Store, previously implemented for Hazelcast JCache. Please refer to the ???.
  • Hot Restart Store: This new feature provides fast restarting of the Hazelcast clusters. This is achieved by storing the state of the cluster members to the disk. Please refer to the Hot Restart Store section for more details.
  • Discovery Service Provider Interface (Discovery SPI): You can use this SPI to discover Hazelcast instances on cloud environments provided by jclouds®, Kubernetes and many more. The existing discovery mechanisms that Hazelcast provides (Multicast, TCP/IP and Amazon EC2) have been re-implemented on top of this new Discovery SPI. Please refer to the ???.
  • Client Protocol: This feature presents the Hazelcast's new open binary client protocol. Please refer to the ???.
  • Client Cross Version Compatibility: Now you can upgrade your Hazelcast clients independently from servers and other clients. Please refer to the ???.
  • Support for cloud providers through jclouds®: Hazelcast now supports deployments on all the well-known cloud providers through the jclouds® open source library. Please refer to the ???.
  • Ringbuffer and Reliable Topic in Hazelcast Clients: The data structures Ringbuffer and Reliable Topic recently introduced by Hazelcast (with the release 3.5) are now implemented for Hazelcast Clients. Please refer to the ???.
  • Cluster Quorum for Hazelcast JCache: Cluster Quorum checks are now provided for Hazelcast JCache implementations, too. Please refer to Defining a Cluster Quorum to refresh and to the ??? to learn configuring it for JCache.
  • Split Brain Syndrome handler for Hazelcast JCache: Now Split Brain Syndrome is handled in JCache as it is taken care in Hazelcast Map. Please refer to the ???.
  • Partition Lost Listener for Hazelcast JCache: You can listen to partition lost events fired in your Hazelcast JCache implementation. Please refer to the ICache Configuration section.
  • Hazelcast Docker image: Now you can run Hazelcast using our image in the Docker platform. Please refer to the ???.
  • Quartz integration: This feature provides an extension to store Quartz tasks in Hazelcast. Please refer to the ???.
  • Lite Members: With the introduction of Hazelcast Lite Members, you are able to specify certain members in your cluster so that they do not store data. You can use these lite members mostly for your task executions and listener registrations. Please refer to Enabling Lite Members.
  • Indexing and querying of collections: Hazelcast is now able to index and query the objects in a collection, e.g. queue, set and list. Please refer to the ???.
  • Integration with Spring Transaction API: With this release, Hazelcast has extended its Spring integration by having the transactional data structures in the Spring context. Please refer to the ???.
  • Acquiring locks with a lease time: Now, you can try to acquire locks with a lease time. Please refer to the ???.
  • Monitoring the WAN replication: You can now monitor the state of your WAN replications using the Hazelcast Management Center. Please refer to the ???.
  • ENHANCEMENTS:
  • The following are the the enhancements performed for Hazelcast 3.6 release:
  • Replicated Map improvements: The implementation of Hazelcast replicated maps has been revisited. Please especially refer to the Considerations for Replicated Map section.
  • Management Center improvements: ???. Please refer to the ???.
  • Paging Predicate improvements: With the performed improvements, now random page accessing is supported. Please refer to the ???.
  • Rule based query optimizations: This improvement introduces a query optimizer based on static rewriting rules. The optimizer treats predicates as immutable and returns a modified copy when the optimized one is found. Please refer to the ???.
  • WAN replication improvements: ???. Please refer to the ???.
  • Improvements on Hazelcast's OSGI support: ???. Please refer to the ???.
  • The following are the other improvements performed to solve the enhancement issues opened by the Hazelcast customers/team:
  • Inconsistent and potentially buggy design in BasicCompletableFuture. [6080]
  • Starting with "hazelcast-wm 3.3", OSGI Manifest Spring package imports should be optional. [6072] The new client determines the partition ID for every invocation for data structures like queue and list where the partition ID is static. There is no need for this behavior. It should calculate the partition ID for once when the proxy is created and continue to re-use it. [5848]
  • Map.Entry supplied to Entry Processor is not Serializable any more. [5611]
  • The configuration file minimal-json with the provided scope is not picked up by the shade plugin. [5543]
  • In Spring configuration, when a boolean property is injected for hazelcast bean (

New in Hazelcast 3.5.3 (Oct 15, 2015)

  • Enhancements:
  • Cache statistics are only supported at the server side and exposed by `CacheProxy`. At the client side, cache statistics are not calculated and supported so `UnsupportedOperationException` is thrown at `ClientCacheProxy` [#6262].

New in Hazelcast 3.5.1 (Aug 5, 2015)

  • Enhancements:
  • Client instances should spawn threads with their instance names added as prefix [#5671].
  • The method com.hazelcast.spi.impl.classicscheduler.ResponseThread::process may catch throwables. When this occurs, it logs an unhelpful message, and ignores the actual exception. This method should be improved to additionally log the cause, or at least the exception class and message [#5619].
  • The element min-eviction-check-millis in the map configuration does not exist in documentation [#5614].
  • Fixes:
  • Hazelcast Management Center uses UpdateMapConfigOperation to update map configurations. This operation simply replaces the map configuration of the related map container. However, this replacement has no effect for maxIdleSeconds and timeToLiveSeconds properties of the map configuration since they are not used in the map container directly. They are assigned to the final variables during map container creation and never touched again [#5593].
  • Destroying a map just after creating it produces double create/destroy events for DistributedObjectListener [#5592].
  • Map does not allow changing its maximum size, TTL and maximum idle properties. However, these fields are editable in the "Map Config" popup of Management Center. These fields should be disabled to prevent misguiding [#5591].
  • Map is destroyed using IMap.destroy() but then it is immediately recreated [#5554].
  • There should be a better calculation when calling the method getApproximateMaxSize() related to casting. Its return type is int and this causes the map entries to be evicted all the time when, for example, the eviction policy for an IMap is set to heap percentage with the value 1% [#5516].
  • All onResponse() calls on a MultiExecutionCallback should be made before the method onComplete() is called. There exists a race condition in ExecutionCallbackAdapterFactory which permits the method onComplete() to be called before all onReponse() calls are made [#5490].
  • Hazelcast Management Center "Scripting" tab is not refreshed when a new node joins to the cluster [#4738].
  • When updating a map entry which is replicated over WAN, the TTL (time to live) is not honored in the remote cluster map. When the timeout expires, the entry disappears from the cluster in which the key is owned, however it remains in the remote cluster [#254].

New in Hazelcast 3.5 (Jun 18, 2015)

  • New features:
  • Async Back Pressure: The Back Pressure introduced with Hazelcast 3.4 now supports async operations.
  • Client Configuration Import: Hazelcast now supports replacing variables with system properties in the declarative configuration of Hazelcast client. Moreover, now you can compose the Hazelcast client declarative configuration out of smaller configuration snippets.
  • Cluster Quorum: This feature enables you to define the minimum number of machines required in a cluster for the cluster to remain in an operational state.
  • Hazelcast Client Protocol: Starting with 3.5, Hazelcast introduces the support for different versions of clients in a cluster. Please keep in mind that this support is not valid for the releases before 3.5.
  • Listener for Lost Partitions: This feature notifies you for possible data loss occurrences.
  • Increased Visibility of Slow Operations: With the introduction of the `SlowOperationDetector` feature, slow operations are logged and can be seen on the Hazelcast Management Center.
  • Enterprise WAN Replication: Hazelcast Enterprise implementation of the WAN Replication.
  • Sub-Listener Interfaces for Map Listener: This feature enables you to listen to map-wide or entry-based events. With this new feature, the listener formerly known as `EntryListener` has been changed to `MapListener` and `MapListener` has sub-interfaces to catch map/entry related events.
  • Scalable Map Loader: With this feature, you can load your keys incrementally if the number of your keys is large.
  • Near Cache for JCache: Now you can use a near cache with Hazelcast's JCache implementation.
  • Fail Fast on Invalid Configuration: With this feature, Hazelcast throws a meaningful exception if there is an error in the declarative or programmatic configuration.
  • Continuous Query Caching: (Enterprise only, since 3.5) Provides an always up to date view of an IMap according to the given predicate.
  • Management of Unbounded Return Values: Introduces a `QueryResultSizeLimiter`.
  • Enhancements:
  • Eventing System Improvements: RingBuffer and Reliable Topic structures are introduced.
  • XA Transactions Improvements: With this improvement, you can now obtain a Hazelcast XA Resource instance through `HazelcastInstance`.
  • Query: Predicates are now evaluated using a single thread to prevent a parallel slowdown. This has been proven to be beneficent for most of the use cases. You can revert to the old behavior by setting the `hazelcast.query.predicate.parallel.evaluation` system property to `true`.
  • Improvements:
  • While configuring JCache, duration of the `ExpiryPolicy` can be set programmatically but not declaratively [#5347].
  • Since near cache is not supported as embedded but only at client, at the moment, there is no need for `NearCacheConfig` in `CacheConfig` [#5215].
  • `SlowOperationDetector` should have an option to not to log the stacktraces to the log file. There is no need to have the stacktraces written to the normal log file if the Hazelcast Management Center or the performance monitor is being used [#5043].
  • There are no Spring tags available for Native Memory configuration [#4772].
  • In the class `BasicInvocationFuture`, there is no need to create an additional `AtomicInteger` object. It should be replaced with `AtomicIntegerFieldUpdater` [#4408].
  • There is no need to use the class `IsStillExecutingOperation` to check if an operation is running locally. One can directly access to the scheduler [#4407].
  • Configuring NearCache in a Client/Server system only talks about the programmatic configuration of NearCache on the clients. The declarative configuration (XML) of the same is not mentioned [#4376].
  • The JavaDoc for the methods `KeyValueSource.hasNext/element/key` and `Iterator.hasNext/next` should emphasize the differences between each other, i.e. the state changing behavior should be clarified [#4218].
  • While migration is in progress, the nodes will have different partition state versions. If the query is running at that time, it can get results from the nodes at different stages of the migration. By adding partition state version to the query results, it can be checked whether the migration was happening and the query can be re-run [#4206].
  • XML Config Schema does not allow to set a `SecurityInterceptor` Implementation [#4118].
  • Currently, certain types of remote executed calls are stored into the `executingCalls` map. The key (and value) is a `RemoteCallKey` object. The functionality provided is the ability to ask on the remote side if an operation is still executing. For a partition-aware operation, this is not needed. When an operation is scheduled by a partition specific operation thread, the operation can be stored in a volatile field in that thread [#4079].
  • The class `TcpIpJoinerOverAWS` fails at AWS' recently launched eu-central-1 region. The reason for the fail is that the region requires v4 signatures [#3963].
  • The `hazelcast-spring-.xsd` should include the User Defined Services (SPI) elements and attributes [#3565].
  • Map wildcard matching is confusing. There should be a pluggable wildcard configuration
  • resolver [#2431].
  • Fixes:
  • Operation timeout mechanism is not working [#5468].
  • `MapLoader` exception is not logged: Exception should be logged and propagated back to the client that triggered the loading of the map [#5430].
  • Replicated Map documentation page does not mention that it is in the beta stage [#5424].
  • The method `XAResource.rollback()` should not need the transaction to be in the prepared state when called from another member/client [#5401].
  • The method `XAResource.end()` should not need to check `threadId` [#5400].
  • The method `IList::remove()` should publish the event `REMOVED` [#5386].
  • `IllegalStateException` with wrong partition is thrown when the method `IMap::getOperation()` is invoked [#5341].
  • `WrongTarget` warnings appear in the log since the operations are not sent to the replicas when a map has no backups [#5324].
  • When the method `finalizeCombine()` is used, Hazelcast throws `NullPointerException` [#5283].
  • `WanBatchReplication` causes `OutOfMemoryException` when the default value for WAN Replication Batch Size (50) is used [#5280].
  • When testing Hazelcast, it does not start as an OSGI bundle. After the OSGI package was refactored, the dynamic class loading of the Script engine was missed [#5274].
  • XA Example from Section 11.3.5 in the Reference Manual broken after the latest XA Improvements are committed [#5273].
  • XA Transaction throws `TransactionException` instead of an `XAException` on timeout [#5260].
  • The test for unbounded return values runs forever with the new client implementation [#5230].
  • The new client method `getAsync()` fails with a `NegativeArraySizeException` [#5229].
  • The method `putTransient` actuated the MapStore unexpectedly in an environment with multiple instances [#5225].
  • Changes made by the interceptor do not appear in the backup [#5211].
  • The method `removeAttribute` will prevent any updates by the method `setAttribute` in the deferred write mode [#5186].
  • Backward compatibility of eviction configuration for cache is broken since `CacheEvictionConfig` class was renamed to `EvictionConfig` for general usage [#5180].
  • Value passed into `ICompletableFuture.onResponse()` is not deserialized [#5158].
  • Map Eviction section in the Reference Manual needs more clarification [#5120].
  • When host names are not registered in DNS or in `/etc/hosts` and the members are configured manually with IP addresses and while one node is running, a second node joins to the cluster 5 minutes after it started [#5072].
  • The method `OperationService.asyncInvokeOnPartition()` sometimes fails [#5069].
  • The `SlowOperationDTO.operation` shows only the class name, not the package. This can lead to ambiguity and the actual class cannot be tracked [#5041].
  • There is no documentation comment for the `MessageListener` interface of ITopic [#5019].
  • The method `InvocationFuture.isDone` returns `true` as soon as there is a response including `WAIT_RESPONSE`. However, `WAIT_RESPONSE` is an intermediate response, not a final one [#5002].
  • The method `InvocationFuture.andThen` does not deal with the null response correctly [#5001].
  • `CacheCreationTest` fails due to the multiple `TestHazelcastInstanceFactory` creations in the same test [#4987].
  • When Spring dependency is upgraded to 4.1.x, an exception related to the `putIfAbsent` method is thrown [#4981].
  • HazelcastCacheManager should offer a way to access the underlying cache manager [#4978].
  • Hazelcast Client code allows to use the value *0* for the `connectionAttemptLimit` property which internally results in `int.maxValue`. However, the XSD of the Hazelcast Spring configuration requires it to be at least 1 [#4967].
  • Updates from Entry Processor does not take `write-coalescing` into account [#4967].
  • CachingProvider does not honor custom URI [#4943].
  • Test for the method `getLocalExecutorStats()` fails spuriously [#4911].
  • Missing documentation of network configuration for JCache [#4905].
  • Slow operation detector throws a `NullPointerException` [#4855].
  • Consider use of `System.nanoTime` in `sleepAtLeast` test code [#4835].
  • When upgraded to 3.5-SNAPSHOT for testing, Hazelcast project gives a warning that mentions a missing configuration for `hazelcastmq.txn-topic` [#4790].
  • `ClassNotFoundException` when using WAR classes with JCache API [#4775].
  • When Hazelcast is installed using Maven in Windows environment, the test `XmlConfigImportVariableReplacementTest` fails [#4758].
  • When a request cannot be executed due to a problem (connection error, etc.), if the operation redo is enabled, request is retried. Retried operations are offloaded to an executor, but after offloading, the user thread still tries to retry the request. This causes anomalies like operations being executed twice or operation responses being handled incorrectly [#4693].
  • Client destroys all connections when a reconnection happens [#4692].
  • The `size()` method for a replicated map should return `0` when the entry is removed [#4666].
  • `NullPointerException` on the `CachePutBackupOperation` class [#4660].
  • When removing keys from a MultiMap with a listener, the method `entryRemoved()` is called. In order to get the removed value, one must call the `event.getValue()` instead of `event.getOldValue()` [#4644].
  • Unnecessary deserialization at the server side when using `Cache.get()` [#4632].
  • Operation timeout exception during `IMap.loadAllKeys()` [#4618].
  • There have been Hazelcast AWS exceptions after the version of AWS signer had changed (from v2 to v4) [#4571].
  • In the declarative configuration; when a variable is used to specify the value of an element or attribute, Hazelcast ignores the strings that come before the variable [#4533].
  • `LocalRegionCache` cleanup is working wrongly [#4445].
  • Repeatable-read does not work in a transaction [#4414].
  • Hazelcast instance name with `Hibernate` still creates multiple instances [#4374].
  • In Hazelcast 3.3.4, `FinalizeJoinOperation` times out if the method `MapStore.loadAllKeys()` takes more than 5 seconds [#4348].
  • JCache sync listener completion latch problems: Status of `ICompletableFuture` while waiting for completion latch in the cache must be checked [#4335].
  • Classloader issue with `javax.cache.api` and Hazelcast 3.3.1 [#3792].
  • Failed backup operation on transaction commit causes ""Nested transactions are not allowed!" warning [#3577].
  • Hazelcast Client should not ignore the fact that the XML is for server and should not use default XML feature to connect to `localhost` [#3256].
  • Owner connection `read()` forever [#3401].

New in Hazelcast 3.4.3 (Jun 17, 2015)

  • Enhancements:
  • Expose `TcpIpJoiner.MAX_PORT_TRIES` as a configurable property [#5062].
  • Fixes:
  • This section lists issues solved for Hazelcast 3.4.3 release.
  • Subsequent remove operations may cause reading of stale value from the map store [#5368].
  • Write-behind may cause reading of stale value upon migration [#5339].
  • Hazelcast client is unresponsive. `OperationTimeoutException` is seen in the logs [#5338].
  • Last update time of an entry should not be changed after `getAll()` is invoked [#5333].
  • `AtomicReference.alterAndGet()` throws `HazelcastSerializationException` [#5265].
  • `ICompletableFuture` callback from the method `getAsync` is not always invoked [#5133].
  • Warnings and exceptions are logged when closing the client connection [#4966].
  • `CacheConfig` is not created on the cluster if the executer of `CacheCreateConfigOperation` has already a `CacheConfig` [#4960].
  • The schema does not allow for an explict `hz:replicatedMap` element to be created. One can be created inside `hz:config` but not as a definition for a concrete Replicated Map. Therefore, at present it is impossible to define a Replicated Map using Spring. [#4958].
  • `ResponseThread` and `InvocationRegistry.InspectionThread` reset and retry operations. Since these threads did not implement `NIOTHread`, the `OperationExecutor` is free to execute tasks on these threads and that is not desirable [#4929].
  • The method `CacheManager.getCache()` does not re-open the closed cache. It should let access to the closed cache and re-open it. Cache can be accessed by `getCache` but it is still closed [#4631].
  • The method `close()` of a Closeable `CacheLoader` is called without explicitly calling the method `Cache.close()` [#4617].
  • The method `Cache.close()` does not call the method `close()` of registered Closeable `CacheEntryListener` [#4616].
  • The method `awaitNanos()` returns the wrong value for both the `ClientConditionProxy` and `ConditionImpl` classes [#4603].
  • The method `NotEqualPredicate` should return false if entry is null (without index) and also if index is present, it should not throw an exception with null values [#4525].
  • When running Hazelcast with Spring and Hibernate 4 and when an application is started, the error related to `org/hibernate/cache/QueryResultsRegion` is produced [#4519].
  • `OperationTimeoutException` when calling `get` on task future after `hazelcast.operation.call.timeout.millis` [#4398].
  • Predicates with null values throws exception for unordered indexes [#4373].
  • The method `queue.take()` does not get interrupted on shutdown [#4143].

New in Hazelcast 3.5 EA (May 13, 2015)

  • New Features:
  • Async Back Pressure: The Back Pressure introduced with Hazelcast 3.4 now supports async operations. For more information, please see the Back Pressure section.
  • Client Configuration Import: Hazelcast now supports replacing variables with system properties in the declarative configuration of Hazelcast client. Moreover, now you can compose the Hazelcast client declarative configuration out of smaller configuration snippets. For more information, please see the Composing Declarative Configuration section.
  • Cluster Quorum: This feature enables you to define the minimum number of machines required in a cluster for the cluster to remain in an operational state. For more information, please see the Cluster Quorum section.
  • Hazelcast Client Protocol: Starting with 3.5, Hazelcast introduces the support for different versions of clients in a cluster. Please keep in mind that this support is not valid for the releases before 3.5.
  • Complete Implementation of XA Transactions
  • Continuous Query Caching
  • Dynamic Selector Rebalancing
  • Fail Fast on Invalid Configuration
  • Enterprise WAN Replication
  • Increased Visibility of Slow Operations
  • Listener for Lost Partitions
  • Management of Unbounded Return Values
  • Near Cache for JCache
  • New License Management Features
  • One Listener Interface per Event
  • Scalable Map Loader
  • Enhancements:
  • Since near cache is not supported as embedded but only at client, at the moment, there is no need for NearCacheConfig in CacheConfig [#5215].
  • SlowOperationDetector should have an option to not to log the stacktraces to the log file. There is no need to have the stacktraces written to the normal log file if the Hazelcast Management Center or the performance monitor is being used [#5043].
  • There are no Spring tags available for Native Memory configuration [#4772].
  • In the class BasicInvocationFuture, there is no need to create an additional AtomicInteger object. It should be replaced with AtomicIntegerFieldUpdater [#4408].
  • There is no need to use the class IsStillExecutingOperation to check if an operation is running locally. One can directly access to the scheduler [#4407].
  • Configuring NearCache in a Client/Server system only talks about the programmatic configuration of NearCache on the clients. The declarative configuration (XML) of the same is not mentioned [#4376].
  • The JavaDoc for the methods KeyValueSource.hasNext/element/key and Iterator.hasNext/next should emphasize the differences between each other, i.e. the state changing behavior should be clarified [#4218].
  • While migration is in progress, the nodes will have different partition state versions. If the query is running at that time, it can get results from the nodes at different stages of the migration. By adding partition state version to the query results, it can be checked whether the migration was happening and the query can be re-run [#4206].
  • XML Config Schema does not allow to set a SecurityInterceptor Implementation [#4118].
  • Currently, certain types of remote executed calls are stored into the executingCalls map. The key (and value) is a RemoteCallKey object. The functionality provided is the ability to ask on the remote side if an operation is still executing. For a partition-aware operation, this is not needed. When an operation is scheduled by a partition specific operation thread, the operation can be stored in a volatile field in that thread [#4079].
  • The class TcpIpJoinerOverAWS fails at AWS' recently launched eu-central-1 region. The reason for the fail is that the region requires v4 signatures [##3963].
  • The hazelcast-spring-.xsd should include the User Defined Services (SPI) elements and attributes [##3565].
  • Map wildcard matching is confusing. There should be a pluggable wildcard configuration resolver [##2431].
  • Fixes:
  • The test for unbounded return values runs forever with the new client implementation [#5230].
  • The method putTransient actuated the MapStore unexpectedly in an environment with multiple instances [#5225].
  • The method removeAttribute will prevent any updates by the method setAttribute in the deferred write mode [#5186].
  • Backward compatibility of eviction configuration for cache is broken since CacheEvictionConfig class was renamed to EvictionConfig for general usage [#5180].
  • When host names are not registered in DNS or in /etc/hosts and the members are configured manually with IP addresses and while one node is running, a second node joins to the cluster 5 minutes after it started [#5072].
  • The SlowOperationDTO.operation shows only the class name, not the package. This can lead to ambiguity and the actual class cannot be tracked [#5041].
  • There is no documentation comment for the MessageListener interface of ITopic [#5019].
  • The method InvocationFuture.isDone returns true as soon as there is a response including WAIT_RESPONSE. However, WAIT_RESPONSE is an intermediate response, not a final one [#5002].
  • The method InvocationFuture.andThen does not deal with the null response correctly [#5001].
  • CacheCreationTest fails due to the multiple TestHazelcastInstanceFactory creations in the same test [#4987].
  • When Spring dependency is upgraded to 4.1.x, an exception related to the putIfAbsent method is thrown [#4981].
  • Hazelcast Client code allows to use the value 0 for the connectionAttemptLimit property which internally results in int.maxValue. However, the XSD of the Hazelcast Spring configuration requires it to be at least 1 [#4967].
  • When upgraded to 3.5-SNAPSHOT for testing, Hazelcast project gives a warning that mentions a missing configuration for hazelcastmq.txn-topic [#4790].
  • When Hazelcast is installed using Maven in Windows environment, the test XmlConfigImportVariableReplacementTest fails [#4758].
  • When a request cannot be executed due to a problem (connection error, etc.), if the operation redo is enabled, request is retried. Retried operations are offloaded to an executor, but after offloading, the user thread still tries to retry the request. This causes anomalies like operations being executed twice or operation responses being handled incorrectly [#4693].
  • The size() method for a replicated map should return 0 when the entry is removed [#4666].
  • There have been Hazelcast AWS exceptions after the version of AWS signer had changed (from v2 to v4) [#4571].
  • In the declarative configuration; when a variable is used to specify the value of an element or attribute, Hazelcast ignores the strings that come before the variable [#4533].
  • In Hazelcast 3.3.4, FinalizeJoinOperation times out if the method MapStore.loadAllKeys() takes more than 5 seconds [#4348].
  • Owner connection read() forever [#3401].

New in Hazelcast 3.4.2 (Mar 27, 2015)

  • Enhancements:
  • The method `contains` for ISet scans all the items [#4620].

New in Hazelcast 3.4 (Dec 27, 2014)

  • New Features:
  • Hazelcast Configuration Import: This feature, which is an element named , enables you to compose the Hazelcast declarative (XML) configuration file out of smaller configuration snippets. For more information, please see Composing XML Configuration section in the Hazelcast Reference Manual.
  • Enhancements:
  • Event packets sent to the client do not have "partitionId" [#4071].
  • Spring Configuration for ReplicatedMap is Missing [#3966].
  • NodeMulticastListener floods log file with INFO-level messages when debug is enabled [#3787].
  • A Hazelcast client should not be a `HazelcastInstance`. It should be a "factory" and this factory should be able to shut down Hazelcast clients. [#3781].
  • InvalidateSessionAttributesEntryProcessor could avoid creating strings at every call to process [#3767].
  • SocketConnector timeout cannot be configured [#3613].
  • The method `MultiMap.get()` returns `collection`, but this method should return the correct collection type (`Set` or `List`) [#3214].
  • HazelcastConnection is not aligned with HazecastInstance [#2997].
  • Support for Log4j 2.x has been implemented [#2345].
  • Management Center console behavior on node shutdown [#2215].
  • When queue-store not enabled, QueueStoreFactory should not be instantiated [#1906].
  • Management Center should be able to say when cluster is safe and all backups are up to date [#963].
  • Fixes:
  • Deadlock happens in MapReduce implementation when there is a high load on the system. The issue has been solved by offloading Distributed MapReduce result collection to the async executor [#4238].
  • When the class `ClientExecutorServiceSubmitTest.java` is compiled using the Eclipse compiler, it gives a compile error: "*The method submit(Runnable, ExecutionCallback) is ambiguous for the type IExecutorService*". The reason is that the `IExecutorService.java` class does not have some generics. The issue has been solved by adding these missing generics to the `IExecutorService.java` class [#4234].
  • JCache declarative listener registration does not work [#4215].
  • JCache evicts the records which are not expired yet. To solve this issue, the `clear` method should be removed that runs when the size is smaller than the minimum eviction element count (`MIN_EVICTION_ELEMENT_COUNT`) [#4124].
  • Hazelcast Enterprise Native Memory operations should be updated in relation with the Hazelcast sync listener changes [#4089].
  • The completion listener (JCache) relies on event ordering but if the completion listener is registered in another node then event ordering is not guaranteed [#4073].
  • AWS joiner classname should be fixed since EC2 discovery is not working after the restructure [#4025].
  • If an IMap has a near cache configured, accessing the near cache via the method `get(key)` does not count as an access to the underlying IMap. The near cache has its own `max-idle-seconds` element. However, if an entry is expired/evicted in the IMap, it also causes a near cache removal operation for the entry regardless of the `max-idle-seconds` of that entry in the near cache. The entry expires and is evicted even if the near cache is being hit constantly. When a near cache is hit, the underlying map should reset the idle time for that key [#4016].
  • Getting a pre-configured Cache instance is not working as expected [#4009].
  • Bounded Queue section in the Reference Manual is unclear and wrong [#3995].
  • The method `checkFullyProcessed` of MapReduce throws null pointer exception. The reason may be that multiple threads attempt to start the final processing state in the JobSupervisor [#3952].
  • Merge operation after a split brain syndrome does not guarantee that the merging is over [#3863].
  • When a client with near cache configuration enabled is shut down, `RejectedExecutionException` is thrown [#3669].
  • In Hazelcast `IMap` and `TransactionalMap`, read-only operations such as `get()`, `containsKey()`, `keySet()`, and `containsValue()` break the transaction atomicity [#3191].
  • Documentation should clearly list features of and differences between native clients [#2385].
  • Sections of Hazelcast configuration should be able to be imported so that these sections can be shared between other Hazelcast configurations [#406].

New in Hazelcast 3.3 (Sep 8, 2014)

  • New Features:
  • Heartbeat for Java client: Before this release, a Java client could not detect a node as dead, if the client is not trying to connect to it. With this heartbeat feature, each node will be pinged periodically. If no response is returned from a node, it will be deemed as dead. Main goal of this feature is to decrease the time for detection of dead (disconnected) nodes by Java clients, so that the user operations will be sent directly to a responsive one.
  • Tomcat 6 and 7 Web Sessions Clustering: Please see Session Replication.
  • Replicated Map implemented: Please see Replicated Map
  • WAN Replication improved: Added configurable replication queue size WAN Replication Queue Size.
  • Data Aggregation implemented: Added common data aggregations, please find Aggregators documentation.
  • EvictAll and LoadAll features for IMap: evictAll and loadAll methods have been introduced to be able to evict all entries except the locked ones and that loads all or a set of keys from a configured map store, respectively.
  • JCache implementation introduced: Please see Hazelcast JCache Implementation for details.
  • Fixes:
  • Hazelcast web session replication filter may die if response committed [#3360].
  • Resource adapter state never reset to isStarted == false, resulting in errors down the line [#3350].
  • Parallel execution of MapStore#store method for the same key triggered by IMap#flush [#3338].
  • when offer null argument in queue throws an exception but add null arg to collection then addAll() this list to queue it doesn't throw an exception [#3330].
  • java.io.FileNotFoundException thrown by MapLoaderTest [#3324].
  • MapMaxSizeTest Stabilizer test with SoftKill [#3291].
  • Incompatible spring and config xsd's [#3275].
  • ExpirationManager partition sorting can fail [#3271].
  • Config validation is broken [#3257].
  • Code Samples for Spring Security + WebFilter Integration [#3252].
  • WebFilter Test Cases are slow [#3250].
  • Man. Center + Weblogic Deployment Problem [#3247].
  • Enabling Multicast and TCP/IP node discovery methods froze my instances [#3246].
  • PagingPredicate.getAnchor doesn't return the correct value [#3241].
  • getOldValue and getValue returns same value when removing item from IMap [#3198].
  • MapTransactionContextTest: member softKill and Mama, HazelcastSerializationException + IegalStateException: Nested [#3196].
  • IMap.delete() should not call MapLoader.load()[#3178].
  • 3.3-RC3+: NPE in method connectionMarkedAsNotResponsive [#3169].
  • High complexity ActionConstants getPermission [#3160].
  • WebFilter.HazelcastHttpSession.isNew() does not check the HC Session Cache [#3132].
  • hazelcast-spring xsd files are not version agnostic [#3131].
  • ClassCastException: java.lang.Integer cannot be cast to java.lang.String Query [#3091].
  • Predicate, returns value, not matching predicate [#3090].
  • Modifications made by Entry Processor are lost in 3.3-RC-2 [#3062].
  • Hazelcast Session Clustering with Spring Security Problem [#3049].
  • PagingPredicate, - returning duplicated elements, resulting in infinite loop [#3047].
  • expirationTime on EntryView not set [#3038].
  • BasicRecordStoreLoader cannot handle retry responses [#3033].
  • Short await() on condition of contended lock causes IllegalStateException [#3025].
  • Indices and Comparable: not documented [#3024].
  • Marking Heartbeat as healthy is too late [#3014].
  • 3.3-RC2: IMap#keySet triggers value deserialization [#3008].
  • map.destroy() throws DistributedObjectDestroyedException [#3001].
  • Stabilizer tests Final profile, Xlarge cluster OperationTimeoutException [#2999].
  • c.h.jca.HazelcastConnection::getExecutorService returns plain ExecutorService [#2986].
  • Serialization NPE, stabilizer-MapStoreTest, 3.3-RC3-SNAPSHOT [#2985].
  • Bug with IMap.getAll() [#2982].
  • Client deadlock on single core machines [#2971].
  • Retrieve number of futures in loop in calling thread - question [#2964].
  • RC2 Fixes:
  • NPE exception in MapStoreTest [#2956].
  • All read operations of map should respect expired keys [#2946].
  • WebFilter does not clean up timed- out sessions [#2930].
  • Fixes data loss issue when partition table is being synced and a node is gracefully shutdown [#2908].
  • evictAll should flush to staging area #2969.
  • MapStoreConfig; implementation instance is not set, when configured via XML [#2898].
  • Fixed AddSessionEntryProcessor [#2955].
  • Added StripedExecutor to WanReplicationService [#2947].
  • Data loss fix in hazelcast-wm module [#2927].
  • Fix leaking empty concurrent hashmaps [#2929].
  • Configured event queue capacity [#2924].
  • Close the owner connection if heartbeat timeout when client is smart [#2916].
  • Client closes owner connection when a connection to the same address is closed [#2921].
  • Set application buffer size to not exceed tls record size [#2914].
  • LocalMapStats does not record stats about locked entries in 3.x [#2876].
  • Concurrency security interceptor [#2874].
  • Client hangs during split, if split occurs due to network error [#2850].
  • Network connection loss does not release lock [#2818].
  • It is not possible to copy the link from http://hazelcast.org/download/ and run wget on it [#2814].

New in Hazelcast 3.2 (Mar 28, 2014)

  • NEW FEATURES:
  • NIO Client: New architecture based on NIO introduced to support more scalable and concurrent client usage.
  • MapReduce Framework: MapReduce implemented for your key-value collections that need to be reduced by grouping the keys. Please see the interview and Chapter 14 - Hazelcast MapReduce.
  • Order/Limit Support: Now you can order and limit results returned by queries performed on Hazelcast Distributed Map.
  • C++ Client: Native C++ client developed for C++ users which can connect to a Hazelcast cluster and realize almost all operations that a node can perform. Please see Native Clients.
  • C# Client: Also, Native C# client that has a very similar API with Native Java client developed. Please see Native Clients.
  • IMPROVEMENTS:
  • Size of a distributed queue via REST API can be returned. [#1809]
  • InitialLoadMode configuration parameter (having Lazy and Eager as values) added to MapStoreConfig. [#1751]
  • Tagging support for Executor Service introduced such that nodes can be tagged for IExecutorService. [1457]
  • getForUpdate() operation for transactional map introduced. [#1033]
  • Entry processor can run on a set of keys with the introduction of executeOnKeys(keys,entryprocessor) method for IMap. [1423]
  • getNearCacheStats() introduced. Statistics for near cache can be retrieved. [#30]
  • FIXES:
  • LocalMapStats.getNearCacheStats() can return null when it is called before a map get that calls initNearCache(). [#2009]
  • testMapWithIndexAfterShutDown fails in OpenJDK. [#2001]
  • Portable Serialization needs objects to be shared between client and server. [#1957]
  • Near cache entries should be locally invalidate on IMap.executeOnKey(). [#1951]
  • OperationTimeoutException is thrown when executing task that runs longer than hazelcast.operation.call.timeout.millis. [#1949]
  • MapStore#store was called when executing AbstractEntryProcessor on backup. [#1940]
  • After an OperationTimeoutException is thrown from `ILock.tryLock() (and after the system is back in a normal state), the named lock remains locked. [#1937]
  • Hazelcast client needs OutOfMemoryErrorDispatcher. [#1933]
  • Near Cache: Caching of local entries may lead to race condition. [#1905]
  • After key owner node dies, it takes too much time for threads to wakeup from condition.await(). [#1879]
  • Possible improvements/fixes for NearCache. [#1863]
  • MultipleEntryBackupOperation does not handle deletion of entries. [#1854]
  • If topics are created/destroyed, then the statistics for that topic are not destroyed and this can cause a memory leak. [#1847]
  • PartitionService backup/replication fixes. [#1840]
  • Cached null values remain in near cache after evict is called. [#1829]
  • NullPointerException in MultiMap when the service is shutdown before the migration is processed. [#1823]
  • Network interruption causes node to continually warn with WrongTargetException. [#1815]
  • DefaultRecordStore#removeAll should be modified so that it keeps "key objects to delete" as a list, not a set. [#1795]
  • Very long operation.run() call stack especially when high partition count is used. [#1745]
  • When executing an entry processor with an index aware predicate, the index is not used, instead the predicate is applied to the entire entry set. [#1719]
  • When one node goes down in a cluster with 2 nodes (where near cache is enabled), containsKey call hangs in the second node. [#1688]
  • When deleting an entry from an entry processor by setting the value to null, it is not removed from the backup store. [#1687]
  • Client calls executed at server side cause unwanted (de)serialization. [#1669]
  • In TrackableJobFuture.get(long, TimeUnit), there is a 100 ms of sleep-spin while waiting for the result of a MapReduce task to be set. [#1648]
  • If storeAll takes much time and if instance terminates while map store is running, data can be lost. [#1644]
  • A missing Spring 4 Cache method added to hazelcast-spring package (namely public T get(Object key, Class type)). [#1627]
  • When eviction tasks are canceled, scheduledExecutorService is not cleaned. [#1595]
  • storeAll() with new value for the same key should not be executed until any previous storeAll() operations with the same key are not completed. [#1592]
  • When using native client to interact with Hazelcast cluster, some JMX MBean attribute values on cluster nodes are not set/updated. [#1576]
  • IMap.getAll(keys) method does not read from near cache. [#1532]
  • Near Cache cache-local-entries attribute is missing in hazelcast-spring-3.2 XSD. [#1524]
  • Exception while executing script in OpenJDK 8. [#1518]
  • Infinite waiting on merge operations when cluster shuts down. [#1504]
  • Client side socket interceptor is not needed to be MemberSocketInterceptor. [#1444]
  • Near cache on the local node should be enabled if its InMemoryFormat is different from that of the map. [#1438]
  • Async EntryProcessor does not deserialize the value before it is called back. [#1433]
  • A submitted task cannot be canceled via the native client. [#1394]
  • executeOnKeys(keys,entryprocessor) introduced on IMap. With this feature entry processor can be run on a set of keys. [#1339]
  • FINEST logging should be guarded where appropriate. [#1332]
  • False errors reported in Eclipse due to schema definition. [#1330]
  • Index based operations are not synchronized with partition changes. [#1297]
  • Management Center: InvocationTargetException in Tomcat console when a node is started and then stopped. [#1267]
  • The system property hazelcast.map.load.chunk.size is being ignored in Hazelcast 3.1. [#1110]
  • Master should fire repartitioning after getting confirmation from nodes. [#1058]
  • SqlPredicate does not Implement equals/hashCode. [#960]
  • DelegatingFuture.isDone seems to always return false until the method DelegatingFuture.get is called. [#850]
  • Predicate support for entry processor. [#826]
  • RC2 FIXES:
  • ClientService.getConnectedClients returns all end points [#1883].
  • MultiMap is throwing ConcurrentModificationExceptions [#1882].
  • executorPoolSize field of ClientConfig cannot be configured using XML [#1867].
  • Partition processing cannot be postponed [#1856].
  • Memory leak at client endpoints [#1842].
  • Errors related to management center configuration on startup [#1821].
  • XML parsing error by client [#1818].
  • ClientReAuthOperation cannot return response without call ID [#1816].
  • MemberAttributeOperationType should be introduced to remove the dependency to MapOperationType [#1811].
  • Entry listener removal from MultiMap [#1810].
  • Change DefaultRecordStore#removeAll to keep "key objects to delete" as a list, not a set [#1795].
  • RC1 FIXES:
  • TransactionalMap does not support put(K,V,long,TimeUnit) [#1718].
  • Entry is not removed from backup store when it is deleted using entry processor [#1687].
  • Possibility of losing data when MapStore takes a long time [#1644].
  • When eviction tasks are cancelled, scheduledExecutorService should be cleaned [#1595].
  • A fix related to StoreAll is needed in a write-behind scenario [#1592].
  • Update problem at map statistics [#1576].
  • Exception while executing script in OpenJDK 8 [#1518].
  • StackOverflowError at AndResultSet [#1501].
  • Near Cache using InMemoryFormat.OBJECT also for local node [#1438].
  • Async entry processor is not deserializing the value before returning [#1433].
  • Distributed Executor; Future Cancel is not working [#1394].
  • HazelcastInstanceFactory$InstanceFuture.get() never returns when newHazelcastInstance() method fails/throws exception [#1253].
  • Changes for Vertx on Openshift [#1176].
  • Serialization should be performed after database interaction for MapStore [#1115].
  • System property related to chunk size is passed over in Hazelcast 3.1 [#1110].
  • Map backups lack eviction of some specific data [#1085].
  • DelegatingFuture.isDone always returns false until get is called [#850].
  • Predicate support for entry processor [#826].
  • Full replication of Maps should be performed [#360].
  • Near cache statistics [#30].

New in Hazelcast 3.2 RC 2 (Mar 7, 2014)

  • Fixed Issues:
  • ClientService.getConnectedClients returns all end points [#1883].
  • MultiMap is throwing ConcurrentModificationExceptions [#1882].
  • executorPoolSize field of ClientConfig cannot be configured using XML [#1867].
  • Partition processing cannot be postponed [#1856].
  • Memory leak at client endpoints [#1842].
  • Errors related to management center configuration on startup [#1821].
  • XML parsing error by client [#1818].
  • ClientReAuthOperation cannot return response without call ID [#1816].
  • MemberAttributeOperationType should be introduced to remove the dependency to MapOperationType [#1811].
  • Entry listener removal from MultiMap [#1810].
  • Change DefaultRecordStore#removeAll to keep "key objects to delete" as a list, not a set [#1795].

New in Hazelcast 3.2 RC 1 (Mar 7, 2014)

  • Fixed Issues:
  • TransactionalMap does not support put(K,V,long,TimeUnit) [#1718].
  • Entry is not removed from backup store when it is deleted using entry processor [#1687].
  • Possibility of losing data when MapStore takes a long time [#1644].
  • When eviction tasks are cancelled, scheduledExecutorService should be cleaned [#1595].
  • A fix related to StoreAll is needed in a write-behind scenario [#1592].
  • Update problem at map statistics [#1576].
  • Exception while executing script in OpenJDK 8 [#1518].
  • StackOverflowError at AndResultSet [#1501].
  • Allow tagging of members for IExecutorService [#1457].
  • Near Cache using InMemoryFormat.OBJECT also for local node [#1438].
  • Async entry processor is not deserializing the value before returning [#1433].
  • Distributed Executor; Future Cancel is not working [#1394].
  • HazelcastInstanceFactory$InstanceFuture.get() never returns when newHazelcastInstance() method fails/throws exception [#1253].
  • Changes for Vertx on Openshift [#1176].
  • Serialization should be performed after database interaction for MapStore [#1115].
  • System property related to chunk size is passed over in Hazelcast 3.1 [#1110].
  • Map backups lack eviction of some specific data [#1085].
  • getForUpdate() for TransactionalMap [#1033].
  • DelegatingFuture.isDone always returns false until get is called [#850].
  • Predicate support for entry processor [#826].
  • Full replication of Maps should be performed [#360].
  • Near cache statistics [#30].

New in Hazelcast 3.1 (Oct 12, 2013)

  • Elastic Memory (Enterprise Edition Only):
  • Elastic Memory is now available. For additional info see Elastic Memory section.
  • Security(Enterprise Edition Only):
  • Hazelcast Security is now available. For additional info see Security section.
  • JCA:
  • Hazelcast JCA integration is back. For additional info see J2EE Integration section.
  • Controlled Partitioning:
  • Controlled Partitioning is the ability to control the partition of certain DistributedObjects like the IQueue, IAtomicLong or ILock. This will make collocating related data easier. For additional info see our blog post: Controlled Partitioning [http://blog.hazelcast.com/blog/2013/08/25/controlled-partitioning/]
  • Hazelcast map also supports custom partitioning strategies. A PartitioningStrategy can be defined in map configuration.
  • Map:
  • TransactionalMap now supports keySet(), keySet(predicate), values() and values(predicate) methods.
  • Eviction based on USED_HEAP_PERCENTAGE or USED_HEAP_SIZE now takes account real heap memory size consumed by map.
  • SqlPredicate now supports '\' as escape character. See MapQuery section for more info.
  • SqlPredicate now supports regular expressions using REGEX keyword. For example; map.values(new
  • SqlPredicate("name REGEX .*earl$")) See MapQuery section for more info.
  • Queue:
  • Hazelcast queue now supports QueueStoreFactory that will be used to create custom QueueStores for persistent queues. QueueStoreFactory is similar to map's MapStoreFactory.
  • TransactionalQueue now supports peek() and peek(timeout, timeunit) methods.
  • Client:
  • Client now has SSL support. See SSL section.
  • Client also supports custom socket implementations using SocketFactory API. A custom socket factory can be defined in ClientConfig; clientConfig.getSocketOptions().setSocketFactory(socketFactory).
  • Other Features:
  • Hazelcast IList and ISet now have their own configurations. They can be configured using config API, xml and Spring. See ListConfig and SetConfig classes.
  • HazelcastInstance.shutdown() method added back.
  • OSGI compatibility is improved significantly. Fixed Issues
  • Version `3.1 [https://github.com/hazelcast/hazelcast/issues?milestone=23&state=closed]

New in Hazelcast 3.0 (Jun 3, 2013)

  • Core architecture:
  • Multithread execution: Multiple thread handling the operations on Node. With Hazelcast 2, there was a single thread.
  • SPI: Service Programming Interface for developing new partitioned services, data structures. All Hazelcast data structures like Map, Queue are reimplemented with SPI.
  • Serialization:
  • IdentifiedDataSerializable: A slightly optimized version of DataSerializable that doesn't use class name and reflection for de-serialization.
  • Portable Serialization: Another Serialization interface that doesn't use reflection and can navigate through binary data and fetch/query/index individual field without having any reflection or whole object de-serialization.
  • Custom Serialization: Support for custom serialization that can be plugged into Hazelcast.
  • Support for multi-version: Support for multiple versions of the same Portable object.
  • Map:
  • Entry Processor : Executing an EntryProcessor on the key or on all entries. Hazelcast implicitly locks the entree and guarantees no migration while the execution of the Processor.
  • Storage Stype : Support for storing entries in Binary, Object and Cached format.
  • Continuous Query : Support for listeners that register with a query and are notified when there is a change on the Map that matches the Query.
  • Interceptors : Ability to intercept the Map operation before/after it is actually executed.
  • Lazy Indexing :Ability to index existing items in the map. No need to add indexes at the very beginning.
  • Queue:
  • No more dependency on the distributed map
  • Scales really well as you have thousands of separate queues.
  • Persistence: Support for persistence with QueueStore.
  • Multimap:
  • Values can be Set/List/Queue.
  • Topic:
  • Total Ordering : Support for global ordering where all Nodes receive all messages in the same order.
  • Transactions:
  • Distributed Transaction : Support for both 1-phase (local) and 2 phase transactions with a totally new API.
  • Client:
  • New Binary Protocol: A new binary protocol based on portable serialization. The same protocol is used for Java/C/C# and other client
  • Smart client: Support for dummy and smart client. Where a dummy client will maintain a connection to only one member, whereas the smart client can route the operations to the Node that owns the data.

New in Hazelcast 2.5.1 (Apr 27, 2013)

  • Fixed issues: [https://github.com/hazelcast/hazelcast/issues?milestone=18&state=closed] 187, 310, 395, 408, 409, 410, 411, 418, 427, 428, 430, 447, 448, 449, 452, 454, 455, 456, 457, 462, 466, 467

New in Hazelcast 2.5 (Jan 16, 2013)

  • New Feature: Java Client has now 'near-cache' support. See Near Cache on Java Client for additional details.
  • New Feature: Management Center alert system, receive alerts based on custom filters. See Management Center
  • Alerting System for additional details.
  • Management Center has now better support for Hazelcast cluster running in OSGI environment.
  • Nodes can be easily shutdown or restarted using Management Center interface.
  • Fixed issues: [https://github.com/hazelcast/hazelcast/issues?milestone=17&state=closed] 377, 386, 389, 392, 394

New in Hazelcast 2.4.1 (Dec 14, 2012)

  • Added Hibernate 2nd level cache local/invalidation mode. See com.hazelcast.hibernate.HazelcastLocalCacheRegionFactory.
  • Added quick clear feature for maps.
  • Fixed issues: [https://github.com/hazelcast/hazelcast/issues?milestone=15&state=closed]
  • 304, 308, 312, 315, 321, 322, 323, 328, 331, 333, 334, 337, 338, 339, 347, 349, 351, 353, 354, 356, 359, 368

New in Hazelcast 2.4 (Nov 17, 2012)

  • Client threads is no longer fixed size, now on it is going to use internal Hazelcast cached thread pool.
  • Added ability to restrict outbound ports that Hazelcast uses to connect other nodes. See OutboundPorts documentation.
  • Fixed issues: [https://github.com/hazelcast/hazelcast/issues?milestone=15&state=closed]
  • 168, 251, 260, 262, 267, 268, 269, 270, 274, 275, 276, 277, 279, 282, 284, 288, 290, 292, 301