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 (CacheFactory.SetAuthInitialize(app_auth);
).
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
properties. 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 apache::geode::client::SharedPtr
with 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
RegionPtr regionPtr;
with
std::shared_ptr<Region> regionPtr;
Other adopted C++11 standards include:
std::chrono
replaces CacheableDate
int32_t
and int16_t
.std:string
replaces char *
PDXSerializable::objectSize()
and DataSerializable::objectSize()
return size_t
std::unordered
mapThe following Version 9 Enums are now defined as C++11 Enum classes in the Version 10 client:
CqOperation
CqState
ExpirationAction
PdxFieldTypes
GemFire Native Client Exceptions, which were implemented as macros in v9, are now classes that inherit from std::exception
.
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:
apache::geode::client::PoolPtr
with std::shared_ptr<apache::geode::client::Pool>
apache::geode::client::RegionPtr
with std::shared_ptr<apache::geode::client::Region>
apache::geode::client::EntryEventPtr
with std::shared_ptr<apache::geode::client::EntryEvent>
apache::geode::client::CachePtr
with std::unique_ptr<apache::geode::client::Cache>
Cache::createPdxInstanceFactory
returns objectCqQuery::getCqAttributesMutator
returns valueCache::createDataInput/Output
returns valueThe 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, geode.properties
and cache.xml
:
s
, m
, h
, etc.).For the 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">
$GFCPP
environment variable is no longer neededenable-chunk-handler-thread
now defaults to false
and replaces disable-chunk-handler-thread
These .NET Framework API classes have changed as follows:
CacheFactory
CreateCacheFactory
, now created via new
SetAuthInitialize
Appdomain
property is no longer a supported propertyGetAnyInstance()
is no longer supported (there is no more global singleton). Make method calls on the specific instance you are working withPoolFactory
PoolManager.CreateFactory
, now via GetPoolFactory
method on Cache
SetEntryTimeToLive
- was int
, now uses TimeSpan
int
, now uses TimeSpan
int
, now uses TimeSpan
int
, now uses TimeSpan
RegionFactory
SetEntryTimeToLive
- was int
, now uses TimeSpan
.IGeodeSerializable
IGeodeSerializable
interface has been renamed to IDataSerializable
.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 |
---|---|
Assert | N/A |
AttributesFactory | Replace with RegionAttributesFactory |
CacheableArrayType, CacheableContainerType, CacheableKeyType | Converted to templates. See INSTALL_DIR/include/geode/CacheableBuiltins.hpp |
DistributedSystem | Used internally |
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 |
VectorOfCacheable | std::vector<std::shared_ptr<T>> |
VectorOfCacheableKey | std::vector<std::shared_ptr<T>> |
VectorOfSharedBase | std::vector<std::shared_ptr<T>> |
VectorT | std::vector<T> |
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. |
RegionAttributesFactory | Replaces AttributesFactory |
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. |