GemFire Native Client Version 10 introduces breaking changes for Version 9 applications. Updating your client applications will require more intervention than merely recompiling.
In general, you will have best performance and reliability if clients and servers both run the latest versions of their respective software.
GemFire server and client software releases follow similar numbering schemes, but they are not released in lockstep. The following diagram illustrates the interoperability between recent versions of GemFire server software and GemFire Native Client software.
VMware GemFire Native Client improvements and new features include:
A modernized C++ API that constitutes a big step forward to fully supporting C++ 11.
Local memory management has been greatly improved, as well as the adoption of a new cache model that allows for multiple cache objects to exist in a given process space.
The .NET Framework interface benefits from all the enhancements made in the C++ interface.
The Native Client now supports IIS application domains and Pivotal Cloud Foundry.
A new architecture that allows for more flexible client-side data models
Improvements to the reflection-based AutoSerializer
The Apache Geode community has a host of examples based on the latest C++ and .NET Framework APIs (https://github.com/apache/geode-native/tree/develop/examples).
For examples of source changes see the Native Client 9 to Native Client 10 Upgrade Sample.
These examples show both the original and new API usage, and may be helpful as starting points for upgrading your application to Native Client 10. To see details for upgrading your particular API usage refer to the Native Client 10 API documentation:
Using Version 10 of the Native Client with your application requires a C++11-compatible compiler.
A major change in Native Client 10 is the change from a singleton-based design to an instance-based design. This gives developers greater programming flexibility, as client cache instances can have completely independent access to the GemFire data grid.
Multiple client-side instances of Cache do not automatically share objects with each another.
The cache creation process in Native Client 10 follows a different pattern and now returns an object (see examples). Each also requires a pool. Native Client 10 further simplifies the cache creation and system architecture with the removal of
DistributedSystem. An instance of
DistributedSystem is no longer needed to manage an application’s “connecting” into the GemFire Java server. This is now managed through a Cache instance.
A note to .NET Framework users of the Native Client: users can pass in an instance of their authorization class into the CacheFactory (
The Native Client serialization APIs for both C++ and .NET Framework have been changed to more closely resemble the behavior of the GemFire Java client. The serializable API has been refactored into data serializable and PDX serializable interfaces. In addition, to be consistent with the Java Server, the new data serializable interface does not have fixed
ClassId is now a parameter passed in to register a given type.
In Native Client 10, many version 9 utility classes, such as shared pointers, have been replaced by their equivalents from the C++11 standard library.
One of the biggest changes made in Native Client 10 is the replacement of custom
std::shared_ptr. The custom base object
apache::geode::client::SharedBase has been removed and is no longer a required derivation to make library objects reference counted; instead objects may simply be wrapped by a
std::shared_ptr<>. Upgrading to Native Client 10 requires replacing all *Ptr types with their C++11 replacements.
For example, replace
Other adopted C++11 standards include:
The following Version 9 Enums are now defined as C++11 Enum classes in the Version 10 client:
GemFire Native Client Exceptions, which were implemented as macros in v9, are now classes that inherit from
Native Client 10 has adopted many more object oriented design patterns. For example, the
CacheFactory now uses a builder pattern and returns a value rather than a pointer.
Other examples of pattern-oriented changes:
The best practice for most applications is to set properties and parameters programmatically. For clients that use the older, file-based scheme, the following changes apply to the system initialization files,
cache.xml file, the schema name space and location have changed. Use
<client-cache xmlns="http://geode.apache.org/schema/cpp-cache" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://geode.apache.org/schema/cpp-cache http://geode.apache.org/schema/cpp-cache/cpp-cache-1.0.xsd" version="1.0">
$GFCPPenvironment variable is no longer needed
enable-chunk-handler-threadnow defaults to
These .NET Framework API classes have changed as follows:
CreateCacheFactory, now created via
Appdomainproperty is no longer a supported property
GetAnyInstance()is no longer supported (there is no more global singleton). Make method calls on the specific instance you are working with
PoolManager.CreateFactory, now via
int, now uses
int, now uses
int, now uses
int, now uses
int, now uses
IGeodeSerializableinterface has been renamed to
The Native Client 10 version of the Session State Provider (SSP) only requires configuration to be set in
Web.Config and the deployment of server-side functions.
The following classes have changed or are no longer present in the current release.
|Version 9: Removed Class||Version 10: Recommended Action|
|AttributesFactory||Replace with RegionAttributesFactory|
|CacheableArrayType, CacheableContainerType, CacheableKeyType||Converted to templates. See INSTALL_DIR/include/geode/CacheableBuiltins.hpp|
|EqualToSB||No longer needed; use std types|
|GeodeTypeIds||Removed from public API|
|HashMapOfCacheable||Replace with std::hash|
|HashMapOfSharedBase||Replace with std::hash|
|HashSB||Replace with std::hash|
|HashSetOfCacheableKey||Replace with std::hash|
|HashSetOfSharedBase||Replace with std::shared_ptr<T>|
|HashSetT||Replace with std::hash|
|InternalCacheTransactionManager2PC||Removed from public API|
|Log||Use LogLevel at cache creation|
|LogFn||Use LogLevel at cache creation|
|LogVarargs||Use LogLevel at cache creation|
|NullSharedBase||Replace with nullptr|
|SelectResultsIterator||Replace with ResultsCollector|
|SharedArrayPtr||Replace with std::shared_ptr<T>|
|SharedBase||Abstract base class no longer needed. Replace with std::shared_ptr<T>|
|SharedPtr||Replace with std::shared_ptr<T>|
|SPEHelper||Exception helper no longer needed after move from SharedPtr to std::shared_ptr|
The following classes have changed or new in the current release.
|New or Renamed Class||Summary of Changes|
|AuthenticatedView||Replaces AuthenticatedCache in v9 API. Used for multi-user authentication.|
|DataSerializable||An interface for objects whose state can be written/read as primitive types. Supersedes Serializable, which is now the superclass of all user objects in the cache that can be serialized.|
|DefaultResultCollector||Default class that gathers results from function execution. The ResultCollector interface also changed.|
|LogLevel||Method returns log level.|
|RegionShortcut||Enum class holding all region types (PROXY, CACHING_PROXY, CACHING_PROXY_ENTRY_LRU, LOCAL_ENTRY_LRU)|
|TypeRegistry||Class for registering a custom serializable type.|