Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
In this Release Notes document, you will find the new features, enhancements and fixes of the Hazelcast 3.7 release.
The numbers in the square brackets refer to the issue number in Hazelcast’s GitHub repository. You can reach
to the full descriptions of the issues at https://github.com/hazelcast/hazelcast/issues/.
1. New Features
- Custom Eviction Policies: You can implement and use your own eviction policy. Please refer to the Custom Eviction Policy section in Hazelcast Reference Manual.
- Discovery SPI Implementation for Microsoft Azure Services: Hazelcast members can be discovered within your Azure resource group. You can add this implementation as a plugin to your projects. Please refer to Hazelcast-Azure plugin page on hazelcast.org/plugins.
- Hazelcast CLI with Scripting: A command line interface that supports scripting. You can automate cluster operations such as start, stop, and force start using shell scripting. Please refer to Hazelcast CLI plugin page on hazelcast.org/plugins.
- Hazelcast for OpenShift and CloudFoundry: Hazelcast members on OpenShift and CloudFoundry can discover each other. Please refer to Hazelcast OpenShift on https://hub.docker.com/r/hazelcast/openshift and Hazelcast CloudFoundry on https://github.com/hazelcast/hazelcast-cloudfoundry.
- Alignment of WAN Replication Clusters: This feature provides a mechanism to align or realign distributed objects in the clusters connected through WAN. WAN replication mirrors changes from a map or cache in one cluster to another. It was maintaining the alignment but was not attaining. Now when the receiving cluster is empty and the sending cluster is not, objects are aligned. And if changes have been dropped for any reason, realignment is attained. Please refer to the Synchronizing WAN Target Cluster section in Hazelcast Reference Manual.
- Fault Tolerant Executor Service: This new data structure is introduced to guarantee that no execution tasks will be lost when a member goes down. Please refer to the Durable Executor Service section in Hazelcast Reference Manual.
2. Enhancements
This section lists the enhancements performed for Hazelcast 3.7 release.
- Near Cache (JCache) Notification Enhancements: You can disable the near cache notifications for each entry and enable/disable notifications of full-flush events. Please refer to the ICache Configuration section and see definition of the new configuration element disable-per-entry-invalidation-events.
- Migration Algorithm Enhancements: With these improvements the possibility of a data loss due to a member crash while the partitions are being migrated is eliminated.
- WAN Replication Integrated with Solace: This integration is achieved through a new JMS endpoint.
- Cloud Discovery SPI Plugin for Multicast: You can use multicast discovery for your Hazelcast platform with client/server topology. Only Hazelcast Java client is supported for this release.
- IMap Eviction Sync with JCache: Hazelcast Map uses now the Hazelcast JCache's eviction algorithm when evicting map entries.
- Docker Image Enhancements: Hazelcast Docker image is able to integrate with the Service Discovery products such as Zookeeper, Consul, Etcd, and Eureka.
- Phone Home Enhancements: Performed to collect new phone home data to learn more about the environment on which Hazelcast runs.
- IMap.putAll() Performance Enhancements: The performance of putAll operation is improved.
- Hazelcast Instance and JCache Integration Enhancements: A direct relation between a Hazelcast instance and JCache is established with this enhancement. You can retrieve and access caches via the method getCache(String name) over HazelcastInstance API. Please refer to the JCache - Hazelcast Instance Integration section.
- Indexing with Predicates for Entry Processors: Entry Processor can use indexing when a predicate is used to filter entries that need to be processed.
- Partition Grouping Enhancements: You can define partition groups, in the same way as the IP address network configuration with wildcard support. You can also configure zone-aware partition groups for your Hazelcast clusters on AWS.
- Prevention of Blocking Reads in Transactions: Now the read operations are blocked only during committing the transactions.
The following are the other improvements performed to solve the enhancement issues opened by the Hazelcast customers/team.
- Performance improvements for the invocation system. [8009]
- The performance log should have an option to log to the 'shared' logger instead of its own file. It would be useful for environments where Hazelcast cannot create or get a performance log file. [7973]
- The path for performance logs, which is currently fixed to the user's working directory should be configurable. [7968]
- Hazelcast IAtomicLong data structure provides synchronous methods only; async versions already exist and are available to Hazelcast members via AsyncAtomicLong interface. Lack of public a async API for IAtomicLong is impeding Hazelcast integrations. [7957]
- It would be better to have a way where near cache notifications for each entry are disabled, but an ability to enable/disable notifications of full-flush events (clear, etc.). [7580]
- Hazelcast should support Transaction API of Spring. [7469], [611]
- For Hazelcast Topic, even the event service's pool size is set to a number larger than one, all of the messages are consumed by only one Hazelcast event thread. The use case includes a single Hazelcast member, both producer and consumer being singletons within the member, and message rate of more than 1000 per second. [7443]
- Partition strategy should be able to be specified not only in the Hazelcast configuration, but also within the Spring context. In addition, an implementing instance should be specified besides the class which implements the partition strategy. [7363]
- Async put operations should be reflected at near cache as soon as the method future.get() returns. In the case of async put operations and LocalUpdatePolicy being CACHE at the client side, entries are put to the near cache asynchronously from another task when the response is received. But with this way, when future.get() returns, entry might not be inside the near cache (but it will be there eventually). [7155]
- For ICache.iterator(), fetchSize is not configurable. [7041]
- Unit tests should have a default timeout. [6978]
- Outgoing ports on Hazelcast clients should be configurable. [6845]
- The method IMap.set does not have a corresponding async version, unlike put and putAsync. The method putAsync is not entirely suitable as an async set, since put returns the previous value mapped to the key, and triggers EntryListeners which may not be desirable. IMap should expose a dedicated setAsync to fulfill the contract for set and have the means to do so asynchronously. [6726]
- Javadoc for EntryProcessor.java should be enhanced by adding notes related to its thread safety. [6593]
- Custom SPI services should be more Spring-friendly. [6567]
- The "spring-aware" should be enabled programmatically too. [6514]
- It would be nice if the type parameters of Predicate were inherited by the IndexAwarePredicate. [1686]
- The class MigrationEndpoint should be a part of Hazelcast SPI package. [1427]
- When a task is submitted to all members, and an executeOnEntries is invoked in the call with a predicate that is based on an index, then the index is ignored and a "full scan" of the "local" members is performed. [1156]
- Inconsistency between the declarative and programmatic configuration of network elements should be solved. [945]
3. Fixes
This section lists the fixed issues for Hazelcast 3.7 and 3.7.x releases.
*3.7.4 Fixes*
- When nodes terminates concurrently, clusterService.removeAddress can fail because
target node is already shutdown. [9324]
- Cache event listeners trigger multiple events when the listener is configured declaratively (XML). [9315]
- When client is connected and the client process is paused, e.g., using a debugger, then the member starts printing the warning message (`Client heartbeat is timed out`) every 10 seconds. [9308]
- Hazelcast client outside the AWS cloud cannot connect to Hazelcast member inside the AWS cloud. [9290]
- In case of a retrying operation, an old heartbeat could still be stored
on the invocation. If the invocation monitor sees this, it does not
understand that this is from an old invocation. It concludes that the
invocation has not received any recent heartbeats and aborts the invocation. [9287]
- Client endpoint may have a different connection than the one it was initially constructed. [9282]
- The method `loadAll(keys)` has to notify `RecordStores` about the end of loading. [9260]
- Partitions should be unavailable/inaccessible until `MigrationAwareServices`
complete commit/rollback during migration and/or promotion. [9235]
- When backups are reordered and a backup with a version greater than (localVersion + 1)
is received, backup is applied but partition replica versions are not updated. [9206]
*3.7.3 Fixes*
- MapLoader.loadAll(true) does not reload after reloading with given keys. [9263]
- The scheduler in TcpIpConnectionManager is not completing after the method instance.shutdown() is called. [9187]
- EntryView's storeTime and expirationTime are not available even though they are set. [9166]
- NullPointerException is thrown while deleting an entry through Entry Processor by setting value to NULL. [9135]
- There is a discrepancy between the Reference Manual and source code in the default value of hazelcast.heartbeat.interval.seconds. [9070]
- When Hazelcast is upgraded from 3.6.5 to 3.7.1, calls to Spring cache generate exceptions. [9023]
- Hazelcast 3.6.x client cannot obtain cache proxy from 3.7.x cluster. Configuration creation and retrieval seem to be not working on 3.6.x clients when they connect to a 3.7.x cluster. Two new system properties added, namely hazelcast.compatibility.3.6.server and hazelcast.compatibility.3.6.client. When upgrading from (assuming that you are using ICache) 3.6.x to 3.7.3 then the servers should be started with -Dhazelcast.compatibility.3.6.client=true to enable existing 3.6.x clients work properly. When upgrading from 3.7.1 and 3.7.2 to 3.7.3 this is not needed.[9006]
- When clients lose connection to the nodes in the cluster, even after the clients reconnected to the cluster, the Entry/MessageListeners never fired again. When you register a listener, the registration to the members are invoked with a timeout value of connection-timeout. Keeping this value short can cause a timeout exception during a listener registration. Therefore, you may need to increase the default value (i.e. 5 seconds), please refer to the Setting Connection Timeout section. [8847]
- There is an unnecessary warning about member side near cache invalidation operations. [8841]
*3.7.2 Fixes*
- The scheduler in TcpIpConnectionManager is not completing after the method instance.shutdown() is called. [9187]
- The container WaitingOperation (which wraps BlockingOperation) is asked for call ID/caller address. But this container object does not have any sensible information, so the heartbeat is not constructed correctly for a blocked operation. [8979]
- JCache backup operation does not propagate the exception CacheNotExists. [8955]
- The log message "unsafe unavailable" is at WARNING level and it also displays the full stack trace. [8852]
- When a predicate for distributed query is executed on a lite member it throws the exception ClassNotFound. [8849]
- While running under non-HotSpot JVM, the exception NoSuchField is thrown. [8835]
*3.7.1 Fixes*
- Aggressive SQL predicate flattening may result in wrong parsing of SQL. [8799]
- To properly configure within Spring context, incorrect client defaults should be fixed. [8761]
- NullPointerException is thrown when the class DefaultNodeExtension has been loaded by two different class loaders. [8755]
- HazelcastInstanceNotActive exception is thrown which is misleading. When a remote member is shutdown while destroying a proxy, no warnings should be logged. [8736]
- Test failure fixes: [8702], [8694], [8460], [7022]
*3.7 Fixes*
The following are the issues solved for 3.7 release.
- `MapAttributeConfig` cannot be loaded in an OSGi environment. [8482]
- Using Hazelcast out of the box with no configuration creates a Peer-to-Peer cluster. As soon as the configuration file `hazelcast.xml` is created by the user, in which only the logging type is set, Hazelcast does not create a cluster but starts in standalone mode. [8481]
- Portable EntryProcessor is not being called on portable objects. [8365]
- In Hazelcast Hibernate modules, there is no JCache dependencies in the classpath. When Hazelcast is upgraded to 3.7-SNAPSHOT, `java.lang.NoClassDefFoundError: javax/cache/Cache` error is thrown when mocking HazelcastInstance. [8352]
- The method `QueryableEntry.serializationService` throws `NullPointerException` when MapReduce is run with extractable entries. Mapping phase of the MapReduce for Portable data formats should be fixed. [8346]
- There is an error when configuring Replicated Map. The return of the method `getConfig` in `ReplicatedMapMBean` should be fixed. [8298]
- TransactionalMap's `removeIfSame` test fails. [8238]
- Distributed Executor Service does not take `ExecutorConfig.isStatisticsEnabled` into account. [8223]
- The method ICache::destroy should remove the cache itself from the owner CacheManager because, otherwise, it causes memory leaks due to the cache proxies which are dead but deemed as working, in AbstractHazelcastCacheManager::caches. [8186]
- Partition promotion is skipped when a node is terminated during the commit. [8174]
- The method IAtomicReference:alter does not persist the changes. When a reference is tried to be altered, no alteration happens. [8149]
- Cache should not expire entities when Duration value is 0. [8148]
- Deserialization of dynamic proxy instances ignores the configured class loader. [8033]
- The attribute "binary" is missing in the MultiMap configuration within Spring context. It does not exist in Hazelcast configuration schema either. [8000]
- If you setup an interceptor to change the data being inserted, the entry listeners still fire with the old value. [7991]
- Unlike the InvocationFuture at the server side, ClientInvocationFuture immediately propagates InterruptedException if the calling thread gets interrupted. This can be a problem when both caller and callee need to agree on whether the operation has executed or not. [7963]
- Hazelcast 3.2.6 uses too much CPU when it is idle. [7943]
- Old version of Portable object from a map cannot be read if new UTF_ARRAY type field is added. [7926]
- Isolated thread pool for priority generic operations. [7857]
- There is an issue when detecting JCache in the classpath. The exception NoClassDefFound is thrown when upgrading to a newer Hazelcast version. [7810]
- Better separators should be used in the exceptions for a clearer read between local and remote stacktraces. [7744]
- Under the section "Operation Threading" of Hazelcast Reference Manual, it states that the default number of partition-aware operation threads is (2 x number of cores). However, when looking at the code and observing the actual number of threads created runtime, it seems like the default value is instead 1 x number of cores instead. [7741]
- The method IMap.executeOnKeys() does not support the empty set (it throws a misleading NullPointerException), and is inconsistent with the method getAll(). [7631]
- Replicated map updates take a very long time. The problematic method is putAll(). The replication logic in this method checks whether the data owners are in sync with the replicas. If they are not, this logic syncs them every 30 seconds. This means, when the updates are not replicated to callers, it takes up to 30 seconds to make all the members synchronized. This period should be configurable. [7617]
- ScheduledExecutorServiceDelegate violates contract of ScheduledExecutorService. It wraps tasks in ScheduledTaskRunner which delegates to a different executor. As a consequence, a task can be executed concurrently and this is a violation of a contract of ScheduledExecutorService. [7611]
- If javax.cache.CacheManager is created with the default settings, the underlying HazelcastInstance is not shutdown when the method close is called on the CacheManager. [7606]
- The method containsKey() of TransactionalMap is blocked when the key was previously locked by the method getForUpdate(). [7588]
- There is an inconsistent behavior when removing from TransactionalMap while the key is locked on IMap. In order to avoid trying to remove an entry that may have already been removed in another uncommitted transaction, IMap.tryLock is used before performing TransactionalMap.remove. This works as expected if the operations occur on a member. But a TransactionException is thrown when it occurs on a client when using XA Transaction. [7587]
- Hazelcast instance should be exposed through com.hazelcast.spring.cache.HazelcastCacheManager. [7571]
- Instance name should not be overridden while creating cache manager from the specified configuration file. Also, it would be better to specify instance name via (]HazelcastCachingProvider.HAZELCAST_INSTANCE_NAME property when instance configuration is taken from the specified configuration file via HazelcastCachingProvider.HAZELCAST_CONFIG_LOCATION.[7567]
- The addInterceptor() method in com.hazelcast.map.impl.MapContainer() is not thread safe. For example, if two concurrent attempts are made to inject the same interceptor, these will be different interceptor objects with the same ID. In this case, the call to interceptorMap.put(id, interceptor) will increase the map size by one, but the call to interceptors.add(interceptor) will increase the list size by two. [7520]
- There are unused elements for Management Center configuration: cluster-id and security-token. [7446]
- For clients, InitialMembershipListener.init is called after MembershipListener.memberAdded. This contradicts the content in the Reference Manual. [7430]
- DiscoveryService's start and destroy methods should be called during the start and shutdown of client when Discovery SPI is enabled. [7347]
- Return cache config as response even though found and created cache config could not put into cache configs inside cache service. [7208]
- In Hazelcast Management Center shutting down a node seems to prevent a node from restarting. [7101]
- MapStoreConfig does not override hashCode and equals methods. Implementation for these two methods should be added. [7035]
- Data is lost when the member dies during repartitioning. [6628]
- Some of the map statistics, such as cost and last access time, are calculated by the traversing map entries. Therefore the calculation time exceeds the time interval reserved for management center state sending thread when entry count is too high. [6442], [5905]
- InvocationFuture's asynchronous calls do not detect the lost operations. [6250]
- The invocation mechanism for blocking operations relies on a periodic timeout so that the operation gets retried. To prevent the calling thread (the thread for future.get) from waiting indefinitely, it will periodically ask the isstillrunning service if the operation is lost. [6248]
- Under some circumstances Hazelcast is getting a corrupt value for IAtomicLongs when a member leaves the cluster. [6074]
- When the client disconnects normally, the server logs an info and a warning message containing the text java.io.EOFException. [6035]
- Some operating systems (such as HPUX or Solaris) and hardware platforms have constraints about the aligned memory operations. In these architectures memory operations must be byte-by-byte as implemented in DirectByteBuffer. [5532]
- Data is lost when a member crashes or is killed during the repartitioning. [5444]
- Data is lost when a member is terminated. Related scenario is a follows [5388]:
Start the first member, and let it populate a map with 100k entries.
Start the second member, and let it start joining the cluster.
Terminate the second member during the join operation.
Observe that data is lost from the first member.
- As for now it is very complicated to listen a getAsync or putAsync result and to integrate it with completable futures or listenable futures. An ICompletableFuture should be returned since it is an interface which seems to extend JDK futures and is returned by an IMap. [5315]
- If multiple Hazelcast members attempt to remove values from a key of a multimap concurrently, and then the members are shut down, the multimap can remain in an inconsistent state with entries remaining after all have been removed. [5220]
- ClassNotFoundException is thrown when trying to get an entry from a TransactionalMap. [4969]
- Profiling a Hazelcast application reveals a thread contention in SpringManagedContext on java.lang.Class.getAnnotation(). And this calls a synchronized method called initAnnotationsIfNecessary(). [4506]
- Hazelcast IMap statistics show negative values. After heavy usage of the cache, the number of misses starts showing up negative. [4022]
- When there is a map with write-behind mode and a map store is configured (eviction is not needed); when the method flush is called in the IMap, the map store's store method can be called concurrently for the same key, namely for those keys which are in the write-behind queue and then forcibly stored by the flush. This is because the flush operation storing all entries in the write-behind queue seems to be executed in the operation thread, while the periodic processing of the write-behind queue is done by an executor service defined in the WriteBehindQueueManager. [3338]
