You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by ec...@apache.org on 2017/08/10 15:20:22 UTC
[14/27] geode-native git commit: GEODE-2729: Remove global variables
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheImpl.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheImpl.cpp b/src/cppcache/src/CacheImpl.cpp
index 4995d60..a7c5157 100644
--- a/src/cppcache/src/CacheImpl.cpp
+++ b/src/cppcache/src/CacheImpl.cpp
@@ -14,56 +14,48 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
-#include "CacheImpl.hpp"
#include <string>
+#include <string>
+
+#include <ace/OS.h>
#include <geode/CacheStatistics.hpp>
+#include <geode/PoolManager.hpp>
+#include <geode/SystemProperties.hpp>
+#include <geode/PoolManager.hpp>
+#include <geode/RegionAttributes.hpp>
+#include <geode/PersistenceManager.hpp>
+
+#include "CacheImpl.hpp"
#include "Utils.hpp"
#include "LocalRegion.hpp"
#include "ExpiryTaskManager.hpp"
-#include <geode/PersistenceManager.hpp>
#include "RegionExpiryHandler.hpp"
#include "TcrMessage.hpp"
#include "ThinClientRegion.hpp"
#include "ThinClientHARegion.hpp"
#include "ThinClientPoolRegion.hpp"
#include "ThinClientPoolDM.hpp"
-#include <geode/PoolManager.hpp>
-#include <geode/SystemProperties.hpp>
#include "Version.hpp"
#include "ClientProxyMembershipID.hpp"
#include "AutoDelete.hpp"
-#include <string>
-#include "ace/OS.h"
-#include <geode/PoolManager.hpp>
-#include <geode/RegionAttributes.hpp>
#include "ThinClientPoolHADM.hpp"
#include "InternalCacheTransactionManager2PCImpl.hpp"
#include "PdxTypeRegistry.hpp"
+#include "SerializationRegistry.hpp"
+#include "ThreadPool.hpp"
using namespace apache::geode::client;
-ExpiryTaskManager* CacheImpl::expiryTaskManager = nullptr;
-CacheImpl* CacheImpl::s_instance = nullptr;
-volatile bool CacheImpl::s_networkhop = false;
-volatile int CacheImpl::s_blacklistBucketTimeout = 0;
-ACE_Recursive_Thread_Mutex CacheImpl::s_nwHopLock;
-volatile int8_t CacheImpl::s_serverGroupFlag = 0;
-
-#define DEFAULT_LRU_MAXIMUM_ENTRIES 100000
-
-ExpiryTaskManager* getCacheImplExpiryTaskManager() {
- return CacheImpl::expiryTaskManager;
-}
-
-CacheImpl::CacheImpl(Cache* c, const char* name, DistributedSystemPtr sys,
- const char* id_data, bool iPUF, bool readPdxSerialized)
- : m_defaultPool(nullptr),
+CacheImpl::CacheImpl(Cache* c, const std::string& name,
+ std::unique_ptr<DistributedSystem> sys, bool iPUF,
+ bool readPdxSerialized)
+ : m_name(name),
+ m_defaultPool(nullptr),
m_ignorePdxUnreadFields(iPUF),
m_readPdxSerialized(readPdxSerialized),
m_closed(false),
m_initialized(false),
- m_distributedSystem(sys),
+ m_distributedSystem(std::move(sys)),
m_implementee(c),
m_cond(m_mutex),
m_attributes(nullptr),
@@ -72,88 +64,42 @@ CacheImpl::CacheImpl(Cache* c, const char* name, DistributedSystemPtr sys,
m_remoteQueryServicePtr(nullptr),
m_destroyPending(false),
m_initDone(false),
- m_adminRegion(nullptr) {
+ m_adminRegion(nullptr),
+ m_memberListForVersionStamp(
+ *(std::make_shared<MemberListForVersionStamp>())),
+ m_serializationRegistry(std::make_shared<SerializationRegistry>()),
+ m_pdxTypeRegistry(std::make_shared<PdxTypeRegistry>(c)),
+ m_expiryTaskManager(
+ std::unique_ptr<ExpiryTaskManager>(new ExpiryTaskManager())),
+ m_clientProxyMembershipIDFactory(m_distributedSystem->getName()),
+ m_threadPool(new ThreadPool(
+ m_distributedSystem->getSystemProperties().threadPoolSize())) {
m_cacheTXManager = InternalCacheTransactionManager2PCPtr(
new InternalCacheTransactionManager2PCImpl(c));
- m_name = Utils::copyString(name);
-
- if (!DistributedSystem::isConnected()) {
- throw IllegalArgumentException("DistributedSystem is not up");
- }
m_regions = new MapOfRegionWithLock();
- SystemProperties* prop = DistributedSystem::getSystemProperties();
- if (prop && prop->heapLRULimitEnabled()) {
- m_evictionControllerPtr = new EvictionController(
- prop->heapLRULimit(), prop->heapLRUDelta(), this);
+ auto& prop = m_distributedSystem->getSystemProperties();
+ if (prop.heapLRULimitEnabled()) {
+ m_evictionControllerPtr =
+ new EvictionController(prop.heapLRULimit(), prop.heapLRUDelta(), this);
m_evictionControllerPtr->start();
LOGINFO("Heap LRU eviction controller thread started");
}
- /*
- else {
- LOGFINE("Eviction controller is nullptr");
- }
- */
- ClientProxyMembershipID::init(sys->getName());
+ m_cacheStats = new CachePerfStats(m_distributedSystem.get()
+ ->getStatisticsManager()
+ ->getStatisticsFactory());
+ m_expiryTaskManager->begin();
- m_cacheStats = new CachePerfStats;
-
- s_instance = this;
m_initialized = true;
-}
-CacheImpl::CacheImpl(Cache* c, const char* name, DistributedSystemPtr sys,
- bool iPUF, bool readPdxSerialized)
- : m_defaultPool(nullptr),
- m_ignorePdxUnreadFields(iPUF),
- m_readPdxSerialized(readPdxSerialized),
- m_closed(false),
- m_initialized(false),
- m_distributedSystem(sys),
- m_implementee(c),
- m_cond(m_mutex),
- m_attributes(nullptr),
- m_evictionControllerPtr(nullptr),
- m_tcrConnectionManager(nullptr),
- m_remoteQueryServicePtr(nullptr),
- m_destroyPending(false),
- m_initDone(false),
- m_adminRegion(nullptr) {
- m_cacheTXManager = InternalCacheTransactionManager2PCPtr(
- new InternalCacheTransactionManager2PCImpl(c));
-
- m_name = Utils::copyString(name);
- if (!DistributedSystem::isConnected()) {
- throw IllegalArgumentException("DistributedSystem is not connected");
- }
- m_regions = new MapOfRegionWithLock();
- SystemProperties* prop = DistributedSystem::getSystemProperties();
- if (prop && prop->heapLRULimitEnabled()) {
- m_evictionControllerPtr = new EvictionController(
- prop->heapLRULimit(), prop->heapLRUDelta(), this);
- m_evictionControllerPtr->start();
- LOGINFO("Heap LRU eviction controller thread started");
- }
- /*
- else {
- LOGFINE("Eviction controller is nullptr");
- }
- */
-
- ClientProxyMembershipID::init(sys->getName());
-
- m_cacheStats = new CachePerfStats;
-
- s_instance = this;
- m_initialized = true;
+ m_poolManager = std::unique_ptr<PoolManager>(new PoolManager(*m_implementee));
}
void CacheImpl::initServices() {
m_tcrConnectionManager = new TcrConnectionManager(this);
- PdxTypeRegistry::init();
if (!m_initDone && m_attributes != nullptr && m_attributes->getEndpoints()) {
- if (PoolManager::getAll().size() > 0 && getCacheMode()) {
+ if (getCache()->getPoolManager().getAll().size() > 0 && getCacheMode()) {
LOGWARN(
"At least one pool has been created so ignoring cache level "
"redundancy setting");
@@ -161,37 +107,18 @@ void CacheImpl::initServices() {
m_tcrConnectionManager->init();
m_remoteQueryServicePtr = std::make_shared<RemoteQueryService>(this);
// StartAdminRegion
- SystemProperties* prop = DistributedSystem::getSystemProperties();
- if (prop && prop->statisticsEnabled()) {
+ auto& prop = m_distributedSystem->getSystemProperties();
+ if (prop.statisticsEnabled()) {
m_adminRegion = AdminRegion::create(this);
}
m_initDone = true;
}
}
-int CacheImpl::blackListBucketTimeouts() { return s_blacklistBucketTimeout; }
-
-void CacheImpl::setBlackListBucketTimeouts() { s_blacklistBucketTimeout += 1; }
-
-bool CacheImpl::getAndResetNetworkHopFlag() {
- ACE_Guard<ACE_Recursive_Thread_Mutex> _lock(s_nwHopLock);
- bool networkhop = CacheImpl::s_networkhop;
- CacheImpl::s_networkhop = false;
- // This log should only appear in tests
- LOGDEBUG("networkhop flag = %d", networkhop);
- return networkhop;
-}
-
-int8_t CacheImpl::getAndResetServerGroupFlag() {
- int8_t serverGroupFlag = CacheImpl::s_serverGroupFlag;
- CacheImpl::s_serverGroupFlag = 0;
- return serverGroupFlag;
-}
-
void CacheImpl::netDown() {
m_tcrConnectionManager->netDown();
- for (const auto& itr : PoolManager::getAll()) {
+ for (const auto& itr : getCache()->getPoolManager().getAll()) {
auto currPool = itr.second;
if (auto poolHADM =
std::dynamic_pointer_cast<ThinClientPoolHADM>(currPool)) {
@@ -223,7 +150,7 @@ CacheImpl::RegionKind CacheImpl::getRegionKind(
regionKind = THINCLIENT_REGION;
}
} else if (rattrs->getPoolName()) {
- PoolPtr pPtr = PoolManager::find(rattrs->getPoolName());
+ PoolPtr pPtr = getCache()->getPoolManager().find(rattrs->getPoolName());
if ((pPtr != nullptr && (pPtr->getSubscriptionRedundancy() > 0 ||
pPtr->getSubscriptionEnabled())) ||
m_tcrConnectionManager->isDurable()) {
@@ -269,7 +196,7 @@ QueryServicePtr CacheImpl::getQueryService(const char* poolName) {
if (poolName == nullptr || strlen(poolName) == 0) {
throw IllegalArgumentException("PoolName is nullptr or not defined..");
}
- PoolPtr pool = PoolManager::find(poolName);
+ PoolPtr pool = getCache()->getPoolManager().find(poolName);
if (pool != nullptr) {
if (pool->isDestroyed()) {
@@ -289,13 +216,9 @@ CacheImpl::~CacheImpl() {
if (m_regions != nullptr) {
delete m_regions;
}
-
- if (m_name != nullptr) {
- delete[] m_name;
- }
}
-const char* CacheImpl::getName() const {
+const std::string& CacheImpl::getName() const {
if (m_closed || m_destroyPending) {
throw CacheClosedException("Cache::getName: cache closed");
}
@@ -310,15 +233,12 @@ void CacheImpl::setAttributes(const CacheAttributesPtr& attrs) {
}
}
-void CacheImpl::getDistributedSystem(DistributedSystemPtr& dptr) const {
- if (m_closed || m_destroyPending) {
- throw CacheClosedException("Cache::getDistributedSystem: cache closed");
- }
- dptr = m_distributedSystem;
+DistributedSystem& CacheImpl::getDistributedSystem() const {
+ return *m_distributedSystem;
}
void CacheImpl::sendNotificationCloseMsgs() {
- for (const auto& iter : PoolManager::getAll()) {
+ for (const auto& iter : getPoolManager().getAll()) {
if (const auto& pool =
std::dynamic_pointer_cast<ThinClientPoolHADM>(iter.second)) {
pool->sendNotificationCloseMsgs();
@@ -387,11 +307,10 @@ void CacheImpl::close(bool keepalive) {
m_cacheStats->close();
}
- PoolManager::close(keepalive);
+ m_poolManager->close(keepalive);
LOGFINE("Closed pool manager with keepalive %s",
keepalive ? "true" : "false");
- PdxTypeRegistry::cleanup();
// Close CachePef Stats
if (m_cacheStats) {
@@ -403,6 +322,9 @@ void CacheImpl::close(bool keepalive) {
GF_SAFE_DELETE(m_tcrConnectionManager);
m_cacheTXManager = nullptr;
+
+ m_expiryTaskManager->stopExpiryTaskManager();
+
m_closed = true;
LOGFINE("Cache closed.");
@@ -410,10 +332,6 @@ void CacheImpl::close(bool keepalive) {
bool CacheImpl::isCacheDestroyPending() const { return m_destroyPending; }
-void CacheImpl::setDefaultPool(PoolPtr pool) { m_defaultPool = pool; }
-
-PoolPtr CacheImpl::getDefaultPool() { return m_defaultPool; }
-
void CacheImpl::validateRegionAttributes(
const char* name, const RegionAttributesPtr& attrs) const {
RegionKind kind = getRegionKind(attrs);
@@ -440,8 +358,8 @@ void CacheImpl::createRegion(const char* name,
if (!(aRegionAttributes->getPoolName())) {
m_tcrConnectionManager->init();
m_remoteQueryServicePtr = std::make_shared<RemoteQueryService>(this);
- SystemProperties* prop = DistributedSystem::getSystemProperties();
- if (prop && prop->statisticsEnabled()) {
+ auto& prop = m_distributedSystem->getSystemProperties();
+ if (prop.statisticsEnabled()) {
m_adminRegion = AdminRegion::create(this);
}
}
@@ -535,11 +453,11 @@ void CacheImpl::createRegion(const char* name,
// When region is created, added that region name in client meta data
// service to fetch its
// metadata for single hop.
- SystemProperties* props = DistributedSystem::getSystemProperties();
- if (!props->isGridClient()) {
+ auto& props = m_distributedSystem->getSystemProperties();
+ if (!props.isGridClient()) {
const char* poolName = aRegionAttributes->getPoolName();
if (poolName != nullptr) {
- PoolPtr pool = PoolManager::find(poolName);
+ PoolPtr pool = getCache()->getPoolManager().find(poolName);
if (pool != nullptr && !pool->isDestroyed() &&
pool->getPRSingleHopEnabled()) {
ThinClientPoolDM* poolDM =
@@ -644,7 +562,7 @@ std::shared_ptr<RegionInternal> CacheImpl::createRegion_internal(
}*/
if (poolName != nullptr) {
- PoolPtr pool = PoolManager::find(poolName);
+ PoolPtr pool = getCache()->getPoolManager().find(poolName);
if (pool != nullptr && !pool->isDestroyed()) {
bool isMultiUserSecureMode = pool->getMultiuserAuthentication();
if (isMultiUserSecureMode && (attrs->getCachingEnabled())) {
@@ -718,7 +636,7 @@ EvictionController* CacheImpl::getEvictionController() {
void CacheImpl::readyForEvents() {
bool autoReadyForEvents =
- DistributedSystem::getSystemProperties()->autoReadyForEvents();
+ m_distributedSystem->getSystemProperties().autoReadyForEvents();
bool isDurable = m_tcrConnectionManager->isDurable();
if (!isDurable && autoReadyForEvents) {
@@ -738,7 +656,7 @@ void CacheImpl::readyForEvents() {
return;
}
- const auto& pools = PoolManager::getAll();
+ const auto& pools = getCache()->getPoolManager().getAll();
if (pools.empty()) throw IllegalStateException("No pools found.");
for (const auto& itr : pools) {
const auto& currPool = itr.second;
@@ -756,7 +674,7 @@ void CacheImpl::readyForEvents() {
}
bool CacheImpl::getEndpointStatus(const std::string& endpoint) {
- const auto& pools = PoolManager::getAll();
+ const auto& pools = getCache()->getPoolManager().getAll();
std::string fullName = endpoint;
if (pools.empty()) {
@@ -792,7 +710,8 @@ void CacheImpl::processMarker() {
if (!q.int_id_->isDestroyed()) {
if (const auto tcrHARegion =
std::dynamic_pointer_cast<ThinClientHARegion>(q.int_id_)) {
- auto regionMsg = new TcrMessageClientMarker(true);
+ auto regionMsg = new TcrMessageClientMarker(
+ this->getCache()->createDataOutput(), true);
tcrHARegion->receiveNotification(regionMsg);
VectorOfRegion subregions;
tcrHARegion->subregions(true, subregions);
@@ -800,7 +719,8 @@ void CacheImpl::processMarker() {
if (!iter->isDestroyed()) {
if (const auto subregion =
std::dynamic_pointer_cast<ThinClientHARegion>(iter)) {
- regionMsg = new TcrMessageClientMarker(true);
+ regionMsg = new TcrMessageClientMarker(
+ this->getCache()->createDataOutput(), true);
subregion->receiveNotification(regionMsg);
}
}
@@ -811,7 +731,7 @@ void CacheImpl::processMarker() {
}
int CacheImpl::getPoolSize(const char* poolName) {
- if (const auto pool = PoolManager::find(poolName)) {
+ if (const auto pool = getCache()->getPoolManager().find(poolName)) {
if (const auto dm = std::dynamic_pointer_cast<ThinClientPoolDM>(pool)) {
return dm->m_poolSize;
}
@@ -821,28 +741,7 @@ int CacheImpl::getPoolSize(const char* poolName) {
RegionFactoryPtr CacheImpl::createRegionFactory(
RegionShortcut preDefinedRegion) {
- return std::make_shared<RegionFactory>(preDefinedRegion);
-}
-
-void CacheImpl::setRegionShortcut(AttributesFactoryPtr attrFact,
- RegionShortcut preDefinedRegionAttr) {
- switch (preDefinedRegionAttr) {
- case PROXY: {
- attrFact->setCachingEnabled(false);
- } break;
- case CACHING_PROXY: {
- attrFact->setCachingEnabled(true);
- } break;
- case CACHING_PROXY_ENTRY_LRU: {
- attrFact->setCachingEnabled(true);
- attrFact->setLruEntriesLimit(DEFAULT_LRU_MAXIMUM_ENTRIES);
- } break;
- case LOCAL: {
- } break;
- case LOCAL_ENTRY_LRU: {
- attrFact->setLruEntriesLimit(DEFAULT_LRU_MAXIMUM_ENTRIES);
- } break;
- }
+ return std::make_shared<RegionFactory>(preDefinedRegion, this);
}
std::map<std::string, RegionAttributesPtr> CacheImpl::getRegionShortcut() {
@@ -886,6 +785,16 @@ std::map<std::string, RegionAttributesPtr> CacheImpl::getRegionShortcut() {
return preDefined;
}
+PdxTypeRegistryPtr CacheImpl::getPdxTypeRegistry() const {
+ return m_pdxTypeRegistry;
+}
+
+SerializationRegistryPtr CacheImpl::getSerializationRegistry() const {
+ return m_serializationRegistry;
+}
+
+ThreadPool* CacheImpl::getThreadPool() { return m_threadPool; }
+
CacheTransactionManagerPtr CacheImpl::getCacheTransactionManager() {
return m_cacheTXManager;
}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheImpl.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheImpl.hpp b/src/cppcache/src/CacheImpl.hpp
index 6de340e..e6da435 100644
--- a/src/cppcache/src/CacheImpl.hpp
+++ b/src/cppcache/src/CacheImpl.hpp
@@ -1,8 +1,3 @@
-#pragma once
-
-#ifndef GEODE_CACHEIMPL_H_
-#define GEODE_CACHEIMPL_H_
-
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -20,6 +15,13 @@
* limitations under the License.
*/
+#pragma once
+
+#ifndef GEODE_CACHEIMPL_H_
+#define GEODE_CACHEIMPL_H_
+
+#include <atomic>
+
#include <geode/geode_globals.hpp>
#include <memory>
@@ -28,7 +30,6 @@
#include <geode/DistributedSystem.hpp>
#include "MapWithLock.hpp"
#include <ace/ACE.h>
-#include <ace/Condition_Recursive_Thread_Mutex.h>
#include <ace/Time_Value.h>
#include <ace/Guard_T.h>
#include <ace/Recursive_Thread_Mutex.h>
@@ -40,13 +41,14 @@
#include "CachePerfStats.hpp"
#include "PdxTypeRegistry.hpp"
#include "MemberListForVersionStamp.hpp"
+#include "ClientProxyMembershipIDFactory.hpp"
#include <string>
#include <string>
#include <map>
#include "NonCopyable.hpp"
-
+#define DEFAULT_LRU_MAXIMUM_ENTRIES 100000
/** @todo period '.' consistency */
/** @todo fix returns to param documentation of result ptr... */
@@ -58,14 +60,18 @@ namespace apache {
namespace geode {
namespace client {
+class ThreadPool;
class CacheFactory;
class ExpiryTaskManager;
+class PdxTypeRegistry;
+class SerializationRegistry;
+typedef std::shared_ptr<SerializationRegistry> SerializationRegistryPtr;
/**
* @class Cache Cache.hpp
* Geode's implementation of a distributed C++ Cache.
*
- * Caches are obtained from static methods on the {@link CacheFactory} class.
+ * Caches are obtained from methods on the {@link CacheFactory} class.
* <p>
* When a cache is created a {@link DistributedSystem} must be specified.
* This system tells the cache where to find other caches on the network
@@ -92,26 +98,28 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable, private NonAssignable {
void setClientCrashTEST() { m_tcrConnectionManager->setClientCrashTEST(); }
// For PrSingleHop C++unit testing.
- static ACE_Recursive_Thread_Mutex s_nwHopLock;
- static void setNetworkHopFlag(bool networkhopflag) {
- ACE_Guard<ACE_Recursive_Thread_Mutex> _lock(s_nwHopLock);
- CacheImpl::s_networkhop = networkhopflag;
- }
- static bool getAndResetNetworkHopFlag();
+ void setNetworkHopFlag(bool networkhopflag) {
+ m_networkhop = networkhopflag;
+ };
+
+ bool getAndResetNetworkHopFlag() { return m_networkhop.exchange(false); }
+
+ int getBlackListBucketTimeouts() { return m_blacklistBucketTimeout; }
+
+ void incBlackListBucketTimeouts() { ++m_blacklistBucketTimeout; }
- static int blackListBucketTimeouts();
- static void setBlackListBucketTimeouts();
+ int8_t getAndResetServerGroupFlag() { return m_serverGroupFlag.exchange(0); }
- static void setServerGroupFlag(int8_t serverGroupFlag) {
- CacheImpl::s_serverGroupFlag = serverGroupFlag;
+ void setServerGroupFlag(int8_t serverGroupFlag) {
+ m_serverGroupFlag = serverGroupFlag;
}
- static int8_t getAndResetServerGroupFlag();
- static MemberListForVersionStampPtr getMemberListForVersionStamp();
+
+ MemberListForVersionStampPtr getMemberListForVersionStamp();
/** Returns the name of this cache.
* @return the string name of this cache
*/
- const char* getName() const;
+ const std::string& getName() const;
/**
* Indicates if this cache has been closed.
@@ -133,7 +141,7 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable, private NonAssignable {
* Returns the distributed system that this cache was
* {@link CacheFactory::create created} with.
*/
- void getDistributedSystem(DistributedSystemPtr& dptr) const;
+ DistributedSystem& getDistributedSystem() const;
/**
* Terminates this object cache and releases all the local resources.
@@ -206,15 +214,19 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable, private NonAssignable {
/**
* @brief constructors
*/
- CacheImpl(Cache* c, const char* name, DistributedSystemPtr sys,
- bool ignorePdxUnreadFields, bool readPdxSerialized);
- CacheImpl(Cache* c, const char* name, DistributedSystemPtr sys,
- const char* id_data, bool ignorePdxUnreadFields,
+ CacheImpl(Cache* c, const std::string& name,
+ std::unique_ptr<DistributedSystem> sys, bool ignorePdxUnreadFields,
bool readPdxSerialized);
+
void initServices();
EvictionController* getEvictionController();
- static ExpiryTaskManager* expiryTaskManager;
+ ExpiryTaskManager& getExpiryTaskManager() { return *m_expiryTaskManager; }
+
+ ClientProxyMembershipIDFactory& getClientProxyMembershipIDFactory() {
+ return m_clientProxyMembershipIDFactory;
+ }
+
Cache* getCache() const { return m_implementee; }
TcrConnectionManager& tcrConnectionManager() {
return *m_tcrConnectionManager;
@@ -243,12 +255,7 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable, private NonAssignable {
void processMarker();
// Pool helpers for unit tests
- static int getPoolSize(const char* poolName);
-
- // CachePerfStats
- CachePerfStats* m_cacheStats;
-
- static inline CacheImpl* getInstance() { return s_instance; };
+ int getPoolSize(const char* poolName);
bool getCacheMode() {
return m_attributes == nullptr ? false : m_attributes->m_cacheMode;
@@ -264,22 +271,30 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable, private NonAssignable {
bool getPdxReadSerialized() { return m_readPdxSerialized; }
bool isCacheDestroyPending() const;
- void setDefaultPool(PoolPtr pool);
+ static std::map<std::string, RegionAttributesPtr> getRegionShortcut();
- PoolPtr getDefaultPool();
+ PdxTypeRegistryPtr getPdxTypeRegistry() const;
- static void setRegionShortcut(AttributesFactoryPtr attrFact,
- RegionShortcut preDefinedRegionAttr);
+ SerializationRegistryPtr getSerializationRegistry() const;
+ inline CachePerfStats& getCachePerfStats() { return *m_cacheStats; };
- static std::map<std::string, RegionAttributesPtr> getRegionShortcut();
+ PoolManager& getPoolManager() { return *m_poolManager; }
+
+ ThreadPool* getThreadPool();
private:
- static volatile bool s_networkhop;
- static volatile int s_blacklistBucketTimeout;
- static volatile int8_t s_serverGroupFlag;
+ std::atomic<bool> m_networkhop;
+ std::atomic<int> m_blacklistBucketTimeout;
+ std::atomic<int8_t> m_serverGroupFlag;
PoolPtr m_defaultPool;
bool m_ignorePdxUnreadFields;
bool m_readPdxSerialized;
+ std::unique_ptr<ExpiryTaskManager> m_expiryTaskManager;
+
+ // CachePerfStats
+ CachePerfStats* m_cacheStats;
+
+ std::unique_ptr<PoolManager> m_poolManager;
enum RegionKind {
CPP_REGION,
@@ -303,11 +318,12 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable, private NonAssignable {
srm.bind((*p).ext_id_, (*p).int_id_);
}
}
- char* m_name;
+ std::string m_name;
bool m_closed;
bool m_initialized;
- DistributedSystemPtr m_distributedSystem;
+ std::unique_ptr<DistributedSystem> m_distributedSystem;
+ ClientProxyMembershipIDFactory m_clientProxyMembershipIDFactory;
MapOfRegionWithLock* m_regions;
Cache* m_implementee;
ACE_Recursive_Thread_Mutex m_mutex;
@@ -319,11 +335,15 @@ class CPPCACHE_EXPORT CacheImpl : private NonCopyable, private NonAssignable {
ACE_RW_Thread_Mutex m_destroyCacheMutex;
volatile bool m_destroyPending;
volatile bool m_initDone;
- static CacheImpl* s_instance;
ACE_Thread_Mutex m_initDoneLock;
AdminRegionPtr m_adminRegion;
CacheTransactionManagerPtr m_cacheTXManager;
+ MemberListForVersionStamp& m_memberListForVersionStamp;
+ SerializationRegistryPtr m_serializationRegistry;
+ PdxTypeRegistryPtr m_pdxTypeRegistry;
+ ThreadPool* m_threadPool;
+
friend class CacheFactory;
friend class Cache;
};
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CachePerfStats.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CachePerfStats.hpp b/src/cppcache/src/CachePerfStats.hpp
index adfda8b..e22d5cd 100644
--- a/src/cppcache/src/CachePerfStats.hpp
+++ b/src/cppcache/src/CachePerfStats.hpp
@@ -1,8 +1,3 @@
-#pragma once
-
-#ifndef GEODE_CACHEPERFSTATS_H_
-#define GEODE_CACHEPERFSTATS_H_
-
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -20,10 +15,17 @@
* limitations under the License.
*/
+#pragma once
+
+#ifndef GEODE_CACHEPERFSTATS_H_
+#define GEODE_CACHEPERFSTATS_H_
+
#include <geode/geode_globals.hpp>
#include <geode/statistics/Statistics.hpp>
#include <geode/statistics/StatisticsFactory.hpp>
+#include "statistics/StatisticsManager.hpp"
+
namespace apache {
namespace geode {
namespace client {
@@ -33,11 +35,8 @@ using namespace apache::geode::statistics;
/** hold statistics for cache.. */
class CPPCACHE_EXPORT CachePerfStats {
public:
- CachePerfStats() {
- StatisticsFactory* factory = StatisticsFactory::getExistingInstance();
- GF_D_ASSERT(!!factory);
-
- StatisticsType* statsType = factory->findType("CachePerfStats");
+ CachePerfStats(StatisticsFactory* factory) {
+ auto statsType = factory->findType("CachePerfStats");
if (statsType == nullptr) {
const bool largerIsBetter = true;
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheRegionHelper.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheRegionHelper.cpp b/src/cppcache/src/CacheRegionHelper.cpp
new file mode 100644
index 0000000..a685d11
--- /dev/null
+++ b/src/cppcache/src/CacheRegionHelper.cpp
@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "CacheRegionHelper.hpp"
+#include "CacheImpl.hpp"
+#include "ProxyCache.hpp"
+
+namespace apache {
+namespace geode {
+namespace client {
+
+CacheImpl* CacheRegionHelper::getCacheImpl(const Cache* cache) {
+ return cache->m_cacheImpl.get();
+}
+
+CacheImpl* CacheRegionHelper::getCacheImpl(const ProxyCache* proxyCache) {
+ return proxyCache->m_cacheImpl;
+}
+
+CacheImpl* CacheRegionHelper::getCacheImpl(const RegionService* regionService) {
+ if (const auto proxyCache = dynamic_cast<const ProxyCache*>(regionService)) {
+ return getCacheImpl(proxyCache);
+ }
+
+ if (const auto cache = dynamic_cast<const Cache*>(regionService)) {
+ return getCacheImpl(cache);
+ }
+
+ return nullptr;
+}
+
+} // namespace client
+} // namespace geode
+} // namespace apache
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheRegionHelper.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheRegionHelper.hpp b/src/cppcache/src/CacheRegionHelper.hpp
index 7e26e1a..a101060 100644
--- a/src/cppcache/src/CacheRegionHelper.hpp
+++ b/src/cppcache/src/CacheRegionHelper.hpp
@@ -1,8 +1,3 @@
-#pragma once
-
-#ifndef GEODE_CACHEREGIONHELPER_H_
-#define GEODE_CACHEREGIONHELPER_H_
-
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -20,32 +15,30 @@
* limitations under the License.
*/
-/**
- * @file
- */
+#pragma once
+
+#ifndef GEODE_CACHEREGIONHELPER_H_
+#define GEODE_CACHEREGIONHELPER_H_
+
#include <geode/geode_globals.hpp>
-#include <geode/Region.hpp>
#include <geode/Cache.hpp>
-#include "CacheImpl.hpp"
-#include <geode/DistributedSystem.hpp>
namespace apache {
namespace geode {
namespace client {
-class CacheRegionHelper {
+class CacheImpl;
+class ProxyCache;
+
+class CPPCACHE_EXPORT CacheRegionHelper {
/**
* CacheHelper
*
*/
public:
- inline static CacheImpl* getCacheImpl(const Cache* cache) {
- return cache->m_cacheImpl.get();
- }
-
- inline static DistributedSystemImpl* getDistributedSystemImpl() {
- return DistributedSystem::m_impl;
- }
+ static CacheImpl* getCacheImpl(const Cache* cache);
+ static CacheImpl* getCacheImpl(const ProxyCache* cache);
+ static CacheImpl* getCacheImpl(const RegionService* cache);
};
} // namespace client
} // namespace geode
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheTransactionManagerImpl.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheTransactionManagerImpl.cpp b/src/cppcache/src/CacheTransactionManagerImpl.cpp
index b5c633d..4a795e6 100644
--- a/src/cppcache/src/CacheTransactionManagerImpl.cpp
+++ b/src/cppcache/src/CacheTransactionManagerImpl.cpp
@@ -25,13 +25,15 @@
#include "CacheTransactionManagerImpl.hpp"
#include <geode/TransactionId.hpp>
#include <geode/ExceptionTypes.hpp>
+#include <geode/PoolManager.hpp>
+
#include "TSSTXStateWrapper.hpp"
#include "TcrMessage.hpp"
#include "ThinClientBaseDM.hpp"
#include "ThinClientPoolDM.hpp"
#include "CacheRegionHelper.hpp"
+#include "CacheImpl.hpp"
#include "TssConnectionWrapper.hpp"
-#include <geode/PoolManager.hpp>
#include "TXCleaner.hpp"
namespace apache {
@@ -63,7 +65,7 @@ void CacheTransactionManagerImpl::commit() {
GF_CACHE_ILLEGAL_STATE_EXCEPTION);
}
- TcrMessageCommit request;
+ TcrMessageCommit request(m_cache->createDataOutput());
TcrMessageReply reply(true, nullptr);
ThinClientPoolDM* tcr_dm = getDM();
@@ -112,8 +114,7 @@ void CacheTransactionManagerImpl::commit() {
}
TXCommitMessagePtr commit =
- std::static_pointer_cast<TXCommitMessage>(
- reply.getValue());
+ std::static_pointer_cast<TXCommitMessage>(reply.getValue());
txCleaner.clean();
commit->apply(m_cache);
@@ -277,7 +278,7 @@ void CacheTransactionManagerImpl::rollback() {
GfErrType CacheTransactionManagerImpl::rollback(TXState* txState,
bool callListener) {
- TcrMessageRollback request;
+ TcrMessageRollback request(m_cache->createDataOutput());
TcrMessageReply reply(true, nullptr);
GfErrType err = GF_NOERR;
ThinClientPoolDM* tcr_dm = getDM();
@@ -360,11 +361,13 @@ TransactionIdPtr CacheTransactionManagerImpl::suspend() {
txState->releaseStickyConnection();
// set the expiry handler for the suspended transaction
- SystemProperties* sysProp = DistributedSystem::getSystemProperties();
+ auto& sysProp = m_cache->getDistributedSystem().getSystemProperties();
SuspendedTxExpiryHandler* handler = new SuspendedTxExpiryHandler(
- this, txState->getTransactionId(), sysProp->suspendedTxTimeout());
- long id = CacheImpl::expiryTaskManager->scheduleExpiryTask(
- handler, sysProp->suspendedTxTimeout() * 60, 0, false);
+ this, txState->getTransactionId(), sysProp.suspendedTxTimeout());
+ long id = CacheRegionHelper::getCacheImpl(m_cache)
+ ->getExpiryTaskManager()
+ .scheduleExpiryTask(handler, sysProp.suspendedTxTimeout() * 60,
+ 0, false);
txState->setSuspendedExpiryTaskId(id);
// add the transaction state to the list of suspended transactions
@@ -451,11 +454,11 @@ void CacheTransactionManagerImpl::resumeTxUsingTxState(TXState* txState,
if (cancelExpiryTask) {
// cancel the expiry task for the transaction
- CacheImpl::expiryTaskManager->cancelTask(
+ CacheRegionHelper::getCacheImpl(m_cache)->getExpiryTaskManager().cancelTask(
txState->getSuspendedExpiryTaskId());
} else {
- CacheImpl::expiryTaskManager->resetTask(txState->getSuspendedExpiryTaskId(),
- 0);
+ CacheRegionHelper::getCacheImpl(m_cache)->getExpiryTaskManager().resetTask(
+ txState->getSuspendedExpiryTaskId(), 0);
}
// set the current state as the state of the suspended transaction
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheTransactionManagerImpl.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheTransactionManagerImpl.hpp b/src/cppcache/src/CacheTransactionManagerImpl.hpp
index a3b220c..e0b8cb4 100644
--- a/src/cppcache/src/CacheTransactionManagerImpl.hpp
+++ b/src/cppcache/src/CacheTransactionManagerImpl.hpp
@@ -60,14 +60,6 @@ class CacheTransactionManagerImpl
virtual TransactionIdPtr getTransactionId();
-
-// inline static int32_t hasher(const SharedBasePtr& p) {
-// return static_cast<int32_t>(reinterpret_cast<intptr_t>(p.get()));
-// }
-//
-// inline static bool equal_to(const SharedBasePtr& x, const SharedBasePtr& y) {
-// return x.get() == y.get();
-// }
TXState* getSuspendedTx(int32_t txId);
protected:
@@ -86,6 +78,7 @@ class CacheTransactionManagerImpl
void addTx(int32_t txId);
bool removeTx(int32_t txId);
bool findTx(int32_t txId);
+
std::map<int32_t, TXState*> m_suspendedTXs;
ACE_Recursive_Thread_Mutex m_suspendedTxLock;
std::vector<int32_t> m_TXs;
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheXmlCreation.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheXmlCreation.cpp b/src/cppcache/src/CacheXmlCreation.cpp
index c140d24..541bcf8 100644
--- a/src/cppcache/src/CacheXmlCreation.cpp
+++ b/src/cppcache/src/CacheXmlCreation.cpp
@@ -22,11 +22,13 @@
using namespace apache::geode::client;
-void CacheXmlCreation::addRootRegion(RegionXmlCreation* root) {
+void CacheXmlCreation::addRootRegion(std::shared_ptr<RegionXmlCreation> root) {
rootRegions.push_back(root);
}
-void CacheXmlCreation::addPool(PoolXmlCreation* pool) { pools.push_back(pool); }
+void CacheXmlCreation::addPool(std::shared_ptr<PoolXmlCreation> pool) {
+ pools.push_back(pool);
+}
void CacheXmlCreation::create(Cache* cache) {
m_cache = cache;
@@ -34,16 +36,12 @@ void CacheXmlCreation::create(Cache* cache) {
m_cache->m_cacheImpl->setPdxReadSerialized(m_readPdxSerialized);
// Create any pools before creating any regions.
- std::vector<PoolXmlCreation*>::iterator pool = pools.begin();
- while (pool != pools.end()) {
- (*pool)->create();
- ++pool;
+ for (const auto& pool : pools) {
+ pool->create(*m_cache);
}
- std::vector<RegionXmlCreation*>::iterator start = rootRegions.begin();
- while (start != rootRegions.end()) {
- (*start)->createRoot(cache);
- ++start;
+ for (const auto& rootRegion : rootRegions) {
+ rootRegion->createRoot(cache);
}
}
@@ -63,18 +61,3 @@ CacheXmlCreation::CacheXmlCreation()
m_pdxIgnoreUnreadFields = false;
m_readPdxSerialized = false;
}
-
-CacheXmlCreation::~CacheXmlCreation() {
- std::vector<RegionXmlCreation*>::iterator start = rootRegions.begin();
- while (start != rootRegions.end()) {
- delete *start;
- *start = nullptr;
- ++start;
- }
- std::vector<PoolXmlCreation*>::iterator pool = pools.begin();
- while (pool != pools.end()) {
- delete *pool;
- *pool = nullptr;
- ++pool;
- }
-}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheXmlCreation.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheXmlCreation.hpp b/src/cppcache/src/CacheXmlCreation.hpp
index ed1813a..754674c 100644
--- a/src/cppcache/src/CacheXmlCreation.hpp
+++ b/src/cppcache/src/CacheXmlCreation.hpp
@@ -47,10 +47,10 @@ class CPPCACHE_EXPORT CacheXmlCreation {
/**
* Adds a root region to the cache
*/
- void addRootRegion(RegionXmlCreation* root);
+ void addRootRegion(std::shared_ptr<RegionXmlCreation> root);
/** Adds a pool to the cache */
- void addPool(PoolXmlCreation* pool);
+ void addPool(std::shared_ptr<PoolXmlCreation> pool);
/**
* Fills in the contents of a {@link Cache} based on this creation
@@ -79,14 +79,14 @@ class CPPCACHE_EXPORT CacheXmlCreation {
bool getPdxReadSerialized(bool val) { return m_readPdxSerialized; }
- ~CacheXmlCreation();
+ ~CacheXmlCreation() = default;
private:
/** This cache's roots */
- std::vector<RegionXmlCreation*> rootRegions;
+ std::vector<std::shared_ptr<RegionXmlCreation>> rootRegions;
/** This cache's pools */
- std::vector<PoolXmlCreation*> pools;
+ std::vector<std::shared_ptr<PoolXmlCreation>> pools;
Cache* m_cache;
bool m_pdxIgnoreUnreadFields;
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheXmlParser.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheXmlParser.cpp b/src/cppcache/src/CacheXmlParser.cpp
index 552a0e1..52ee603 100644
--- a/src/cppcache/src/CacheXmlParser.cpp
+++ b/src/cppcache/src/CacheXmlParser.cpp
@@ -266,7 +266,7 @@ LibraryPersistenceManagerFn CacheXmlParser::managedPersistenceManagerFn =
//////////////////////////////////////////////////////////////////
-CacheXmlParser::CacheXmlParser()
+CacheXmlParser::CacheXmlParser(Cache* cache)
: m_cacheCreation(nullptr),
m_nestedRegions(0),
m_config(nullptr),
@@ -275,7 +275,8 @@ CacheXmlParser::CacheXmlParser()
m_flagIllegalStateException(false),
m_flagAnyOtherException(false),
m_flagExpirationAttribute(false),
- m_poolFactory(nullptr) {
+ m_poolFactory(nullptr),
+ m_cache(cache) {
static xmlSAXHandler saxHandler = {
nullptr, /* internalSubset */
nullptr, /* isStandalone */
@@ -388,9 +389,9 @@ void CacheXmlParser::handleParserErrors(int res) {
* If xml file is well-flrmed but not valid
* @throws UnknownException otherwise
*/
-CacheXmlParser* CacheXmlParser::parse(const char* cacheXml) {
+CacheXmlParser* CacheXmlParser::parse(const char* cacheXml, Cache* cache) {
CacheXmlParser* handler;
- GF_NEW(handler, CacheXmlParser());
+ GF_NEW(handler, CacheXmlParser(cache));
// use RAII to delete the handler object in case of exceptions
DeleteObject<CacheXmlParser> delHandler(handler);
@@ -517,14 +518,13 @@ void CacheXmlParser::endPdx() {}
void CacheXmlParser::startLocator(const xmlChar** atts) {
int attrsCount = 0;
if (!atts) {
-
std::string s =
"XML:No attributes provided for <locator>. "
"A locator requires a host and port";
throw CacheXmlException(s.c_str());
}
+ m_poolFactory = std::static_pointer_cast<PoolFactory>(_stack.top());
- m_poolFactory = reinterpret_cast<PoolFactory*>(_stack.top());
const char* host = nullptr;
const char* port = nullptr;
@@ -554,14 +554,13 @@ void CacheXmlParser::startLocator(const xmlChar** atts) {
void CacheXmlParser::startServer(const xmlChar** atts) {
int attrsCount = 0;
if (!atts) {
-
std::string s =
"XML:No attributes provided for <server>. A server requires a host and "
"port";
throw CacheXmlException(s.c_str());
}
+ auto factory = std::static_pointer_cast<PoolFactory>(_stack.top());
- PoolFactory* factory = reinterpret_cast<PoolFactory*>(_stack.top());
const char* host = nullptr;
const char* port = nullptr;
@@ -596,8 +595,8 @@ void CacheXmlParser::startPool(const xmlChar** atts) {
"A pool cannot be created without a name";
throw CacheXmlException(s.c_str());
}
+ PoolFactoryPtr factory = m_cache->getPoolManager().createFactory();
- PoolFactoryPtr factory = PoolManager::createFactory();
const char* poolName = nullptr;
while (atts[attrsCount] != nullptr) {
@@ -619,15 +618,15 @@ void CacheXmlParser::startPool(const xmlChar** atts) {
throw CacheXmlException(s.c_str());
}
- PoolXmlCreation* poolxml = new PoolXmlCreation(poolName, factory);
+ auto poolxml = std::make_shared<PoolXmlCreation>(poolName, factory);
_stack.push(poolxml);
- _stack.push(factory.get());
+ _stack.push(factory);
}
void CacheXmlParser::endPool() {
_stack.pop(); // remove factory
- PoolXmlCreation* poolxml = reinterpret_cast<PoolXmlCreation*>(_stack.top());
+ auto poolxml = std::static_pointer_cast<PoolXmlCreation>(_stack.top());
_stack.pop(); // remove pool
m_cacheCreation->addPool(poolxml);
}
@@ -747,7 +746,7 @@ void CacheXmlParser::startRegion(const xmlChar** atts, bool isRoot) {
throw CacheXmlException(s.c_str());
}
- RegionXmlCreation* region = new RegionXmlCreation(regionName, isRoot);
+ auto region = std::make_shared<RegionXmlCreation>(regionName, isRoot);
if (!region) {
throw UnknownException("CacheXmlParser::startRegion:Out of memeory");
}
@@ -784,7 +783,7 @@ void CacheXmlParser::startRootRegion(const xmlChar** atts) {
void CacheXmlParser::startRegionAttributes(const xmlChar** atts) {
bool isDistributed = false;
bool isTCR = false;
- AttributesFactory* attrsFactory = nullptr;
+ std::shared_ptr<AttributesFactory> attrsFactory = nullptr;
if (atts) {
int attrsCount = 0;
while (atts[attrsCount] != nullptr) ++attrsCount;
@@ -813,8 +812,8 @@ void CacheXmlParser::startRegionAttributes(const xmlChar** atts) {
}
if (strcmp((char*)atts[i - 1], ID) == 0) {
- RegionXmlCreation* region =
- reinterpret_cast<RegionXmlCreation*>(_stack.top());
+ auto region =
+ std::static_pointer_cast<RegionXmlCreation>(_stack.top());
region->setAttrId(std::string((char*)atts[i]));
} else if (strcmp((char*)atts[i - 1], REFID) == 0) {
refid = (char*)atts[i];
@@ -823,14 +822,15 @@ void CacheXmlParser::startRegionAttributes(const xmlChar** atts) {
}
if (refid == nullptr) {
- RegionXmlCreation* region =
- reinterpret_cast<RegionXmlCreation*>(_stack.top());
- attrsFactory = new AttributesFactory(region->getAttributes());
+ auto region = std::static_pointer_cast<RegionXmlCreation>(_stack.top());
+ attrsFactory =
+ std::make_shared<AttributesFactory>(region->getAttributes());
} else {
std::string refidStr(refid);
if (namedRegions.find(refidStr) != namedRegions.end()) {
- attrsFactory = new AttributesFactory(namedRegions[refidStr]);
+ attrsFactory =
+ std::make_shared<AttributesFactory>(namedRegions[refidStr]);
} else {
std::string s =
"XML:referenced named attribute '" + refidStr + "' does not exist.";
@@ -990,9 +990,8 @@ void CacheXmlParser::startRegionAttributes(const xmlChar** atts) {
} // for loop
} // atts is nullptr
else {
- RegionXmlCreation* region =
- reinterpret_cast<RegionXmlCreation*>(_stack.top());
- attrsFactory = new AttributesFactory(region->getAttributes());
+ auto region = std::static_pointer_cast<RegionXmlCreation>(_stack.top());
+ attrsFactory = std::make_shared<AttributesFactory>(region->getAttributes());
_stack.push(attrsFactory);
}
@@ -1004,8 +1003,7 @@ void CacheXmlParser::startRegionAttributes(const xmlChar** atts) {
}
void CacheXmlParser::endRegionAttributes() {
- AttributesFactory* attrsFactory =
- reinterpret_cast<AttributesFactory*>(_stack.top());
+ auto attrsFactory = std::static_pointer_cast<AttributesFactory>(_stack.top());
_stack.pop();
if (!attrsFactory) {
throw UnknownException(
@@ -1015,8 +1013,7 @@ void CacheXmlParser::endRegionAttributes() {
RegionAttributesPtr regionAttributesPtr =
attrsFactory->createRegionAttributes();
- RegionXmlCreation* regionPtr =
- reinterpret_cast<RegionXmlCreation*>(_stack.top());
+ auto regionPtr = std::static_pointer_cast<RegionXmlCreation>(_stack.top());
if (!regionPtr) {
throw UnknownException("CacheXmlParser::endRegion:Region is null");
}
@@ -1070,7 +1067,8 @@ void CacheXmlParser::startExpirationAttributes(const xmlChar** atts) {
std::string s =
"XML:The attribute <action> of <expiration-attributes> cannot be "
"set to empty string. It should either have a value or the "
- "attribute should be removed. In the latter case the default value "
+ "attribute should be removed. In the latter case the default "
+ "value "
"will be set";
throw CacheXmlException(s.c_str());
} else if (strcmp(INVALIDATE, action) == 0) {
@@ -1100,12 +1098,12 @@ void CacheXmlParser::startExpirationAttributes(const xmlChar** atts) {
}
if (timeOut == nullptr || strcmp(timeOut, "") == 0) {
std::string s =
- "XML:The attribute <timeout> not specified in <expiration-attributes>.";
+ "XML:The attribute <timeout> not specified in "
+ "<expiration-attributes>.";
throw CacheXmlException(s.c_str());
}
- ExpirationAttributes* expireAttr =
- new ExpirationAttributes(timeOutInt, expire);
+ auto expireAttr = std::make_shared<ExpirationAttributes>(timeOutInt, expire);
if (!expireAttr) {
throw UnknownException(
"CacheXmlParser::startExpirationAttributes:Out of memeory");
@@ -1123,7 +1121,8 @@ void CacheXmlParser::startPersistenceManager(const xmlChar** atts) {
while (atts[attrsCount] != nullptr) ++attrsCount;
if (attrsCount > 4) {
std::string s =
- "XML:Incorrect number of attributes provided for <persistence-manager>";
+ "XML:Incorrect number of attributes provided for "
+ "<persistence-manager>";
throw CacheXmlException(s.c_str());
}
char* libraryName = nullptr;
@@ -1142,9 +1141,11 @@ void CacheXmlParser::startPersistenceManager(const xmlChar** atts) {
if (libraryName == nullptr) {
std::string s =
- "XML:The attribute <library-name> of <persistence-manager> cannot "
+ "XML:The attribute <library-name> of <persistence-manager> "
+ "cannot "
"be set to an empty string. It should either have a value or the "
- "attribute should be removed. In the latter case the default value "
+ "attribute should be removed. In the latter case the default "
+ "value "
"will be set";
throw CacheXmlException(s.c_str());
}
@@ -1169,14 +1170,16 @@ void CacheXmlParser::startPersistenceManager(const xmlChar** atts) {
char* name = (char*)atts[i];
std::string temp(name);
std::string s =
- "XML:Incorrect attribute name specified in <persistence-manager>: " +
+ "XML:Incorrect attribute name specified in "
+ "<persistence-manager>: " +
temp;
throw CacheXmlException(s.c_str());
}
}
if (libraryFunctionName == nullptr) {
std::string s =
- "XML:Library function name not specified in the <persistence-manager>";
+ "XML:Library function name not specified in the "
+ "<persistence-manager>";
throw CacheXmlException(s.c_str());
}
@@ -1192,8 +1195,8 @@ void CacheXmlParser::startPersistenceManager(const xmlChar** atts) {
throw CacheXmlException(ex.getMessage());
}
- _stack.push(libraryName);
- _stack.push(libraryFunctionName);
+ _stack.push(std::make_shared<std::string>(std::string(libraryName)));
+ _stack.push(std::make_shared<std::string>(std::string(libraryFunctionName)));
}
void CacheXmlParser::startPersistenceProperties(const xmlChar** atts) {
@@ -1275,9 +1278,11 @@ void CacheXmlParser::startCacheLoader(const xmlChar** atts) {
libraryName = (char*)atts[i];
if (libraryName == nullptr || strcmp(libraryName, "") == 0) {
std::string s =
- "XML:The attribute <library-name> of <cache-loader> cannot be set "
+ "XML:The attribute <library-name> of <cache-loader> cannot be "
+ "set "
"to an empty string. It should either have a value or the "
- "attribute should be removed. In the latter case the default value "
+ "attribute should be removed. In the latter case the default "
+ "value "
"will be set";
throw CacheXmlException(s.c_str());
}
@@ -1316,8 +1321,7 @@ void CacheXmlParser::startCacheLoader(const xmlChar** atts) {
throw CacheXmlException(ex.getMessage());
}
- AttributesFactory* attrsFactory =
- reinterpret_cast<AttributesFactory*>(_stack.top());
+ auto attrsFactory = std::static_pointer_cast<AttributesFactory>(_stack.top());
attrsFactory->setCacheLoader(libraryName, libraryFunctionName);
}
@@ -1384,8 +1388,7 @@ void CacheXmlParser::startCacheListener(const xmlChar** atts) {
throw CacheXmlException(ex.getMessage());
}
- AttributesFactory* attrsFactory =
- reinterpret_cast<AttributesFactory*>(_stack.top());
+ auto attrsFactory = std::static_pointer_cast<AttributesFactory>(_stack.top());
attrsFactory->setCacheListener(libraryName, libraryFunctionName);
}
@@ -1400,7 +1403,8 @@ void CacheXmlParser::startPartitionResolver(const xmlChar** atts) {
while (atts[attrsCount] != nullptr) ++attrsCount;
if (attrsCount > 4) {
std::string s =
- "XML:Incorrect number of attributes provided for <partition-resolver>";
+ "XML:Incorrect number of attributes provided for "
+ "<partition-resolver>";
throw CacheXmlException(s.c_str());
}
@@ -1410,7 +1414,8 @@ void CacheXmlParser::startPartitionResolver(const xmlChar** atts) {
libraryName = (char*)atts[i];
if (libraryName == nullptr || strcmp(libraryName, "") == 0) {
std::string s =
- "XML:The attribute <library-name> of the <partition-resolver> tag "
+ "XML:The attribute <library-name> of the <partition-resolver> "
+ "tag "
"cannot be set to an empty string. It should either have a value "
"or the attribute should be removed. In the latter case the "
"default value will be set";
@@ -1429,7 +1434,8 @@ void CacheXmlParser::startPartitionResolver(const xmlChar** atts) {
char* name = (char*)atts[i];
std::string temp(name);
std::string s =
- "XML:Incorrect attribute name specified in <partition-resolver> : " +
+ "XML:Incorrect attribute name specified in <partition-resolver> "
+ ": " +
temp;
throw CacheXmlException(s.c_str());
}
@@ -1452,8 +1458,7 @@ void CacheXmlParser::startPartitionResolver(const xmlChar** atts) {
throw CacheXmlException(ex.getMessage());
}
- AttributesFactory* attrsFactory =
- reinterpret_cast<AttributesFactory*>(_stack.top());
+ auto attrsFactory = std::static_pointer_cast<AttributesFactory>(_stack.top());
attrsFactory->setPartitionResolver(libraryName, libraryFunctionName);
}
@@ -1478,9 +1483,11 @@ void CacheXmlParser::startCacheWriter(const xmlChar** atts) {
libraryName = (char*)atts[i];
if (libraryName == nullptr || strcmp(libraryName, "") == 0) {
std::string s =
- "XML:The attribute <library-name> of <cache-writer> cannot be set "
+ "XML:The attribute <library-name> of <cache-writer> cannot be "
+ "set "
"to an empty string. It should either have a value or the "
- "attribute should be removed. In the latter case the default value "
+ "attribute should be removed. In the latter case the default "
+ "value "
"will be set";
throw CacheXmlException(s.c_str());
}
@@ -1519,8 +1526,7 @@ void CacheXmlParser::startCacheWriter(const xmlChar** atts) {
throw CacheXmlException(ex.getMessage());
}
- AttributesFactory* attrsFactory =
- reinterpret_cast<AttributesFactory*>(_stack.top());
+ auto attrsFactory = std::static_pointer_cast<AttributesFactory>(_stack.top());
attrsFactory->setCacheWriter(libraryName, libraryFunctionName);
}
@@ -1530,8 +1536,7 @@ void CacheXmlParser::startCacheWriter(const xmlChar** atts) {
* <code>RegionXmlCreation</code>, then it is the parent region.
*/
void CacheXmlParser::endRegion(bool isRoot) {
- RegionXmlCreation* regionPtr =
- reinterpret_cast<RegionXmlCreation*>(_stack.top());
+ auto regionPtr = std::static_pointer_cast<RegionXmlCreation>(_stack.top());
_stack.pop();
if (isRoot) {
if (!_stack.empty()) {
@@ -1549,8 +1554,7 @@ void CacheXmlParser::endRegion(bool isRoot) {
std::string s = "Xml file has incorrectly nested region tags";
throw CacheXmlException(s.c_str());
}
- RegionXmlCreation* parent =
- reinterpret_cast<RegionXmlCreation*>(_stack.top());
+ auto parent = std::static_pointer_cast<RegionXmlCreation>(_stack.top());
parent->addSubregion(regionPtr);
}
}
@@ -1578,12 +1582,11 @@ void CacheXmlParser::endRegionTimeToLive() {
throw CacheXmlException(s.c_str());
}
- ExpirationAttributes* expireAttr =
- reinterpret_cast<ExpirationAttributes*>(_stack.top());
+ auto expireAttr =
+ std::static_pointer_cast<ExpirationAttributes>(_stack.top());
_stack.pop();
- AttributesFactory* attrsFactory =
- reinterpret_cast<AttributesFactory*>(_stack.top());
+ auto attrsFactory = std::static_pointer_cast<AttributesFactory>(_stack.top());
attrsFactory->setRegionTimeToLive(expireAttr->getAction(),
expireAttr->getTimeout());
m_flagExpirationAttribute = false;
@@ -1601,11 +1604,10 @@ void CacheXmlParser::endRegionIdleTime() {
"XML: <region-idle-time> cannot be without <expiration-attributes>";
throw CacheXmlException(s.c_str());
}
- ExpirationAttributes* expireAttr =
- reinterpret_cast<ExpirationAttributes*>(_stack.top());
+ auto expireAttr =
+ std::static_pointer_cast<ExpirationAttributes>(_stack.top());
_stack.pop();
- AttributesFactory* attrsFactory =
- reinterpret_cast<AttributesFactory*>(_stack.top());
+ auto attrsFactory = std::static_pointer_cast<AttributesFactory>(_stack.top());
attrsFactory->setRegionIdleTimeout(expireAttr->getAction(),
expireAttr->getTimeout());
@@ -1625,11 +1627,10 @@ void CacheXmlParser::endEntryTimeToLive() {
"<expiration-attributes>";
throw CacheXmlException(s.c_str());
}
- ExpirationAttributes* expireAttr =
- reinterpret_cast<ExpirationAttributes*>(_stack.top());
+ auto expireAttr =
+ std::static_pointer_cast<ExpirationAttributes>(_stack.top());
_stack.pop();
- AttributesFactory* attrsFactory =
- reinterpret_cast<AttributesFactory*>(_stack.top());
+ auto attrsFactory = std::static_pointer_cast<AttributesFactory>(_stack.top());
attrsFactory->setEntryTimeToLive(expireAttr->getAction(),
expireAttr->getTimeout());
@@ -1648,11 +1649,10 @@ void CacheXmlParser::endEntryIdleTime() {
"XML: <entry-idle-time> cannot be without <expiration-attributes>";
throw CacheXmlException(s.c_str());
}
- ExpirationAttributes* expireAttr =
- reinterpret_cast<ExpirationAttributes*>(_stack.top());
+ auto expireAttr =
+ std::static_pointer_cast<ExpirationAttributes>(_stack.top());
_stack.pop();
- AttributesFactory* attrsFactory =
- reinterpret_cast<AttributesFactory*>(_stack.top());
+ auto attrsFactory = std::static_pointer_cast<AttributesFactory>(_stack.top());
attrsFactory->setEntryIdleTimeout(expireAttr->getAction(),
expireAttr->getTimeout());
m_flagExpirationAttribute = false;
@@ -1663,23 +1663,21 @@ void CacheXmlParser::endEntryIdleTime() {
* factory.
*/
void CacheXmlParser::endPersistenceManager() {
- char* libraryFunctionName = reinterpret_cast<char*>(_stack.top());
+ std::shared_ptr<std::string> libraryFunctionName =
+ std::static_pointer_cast<std::string>(_stack.top());
_stack.pop();
- char* libraryName = reinterpret_cast<char*>(_stack.top());
+ std::shared_ptr<std::string> libraryName =
+ std::static_pointer_cast<std::string>(_stack.top());
_stack.pop();
- AttributesFactory* attrsFactory =
- reinterpret_cast<AttributesFactory*>(_stack.top());
+ auto attrsFactory = std::static_pointer_cast<AttributesFactory>(_stack.top());
if (m_config != nullptr) {
- attrsFactory->setPersistenceManager(libraryName, libraryFunctionName,
- m_config);
+ attrsFactory->setPersistenceManager(libraryName->c_str(),
+ libraryFunctionName->c_str(), m_config);
m_config = nullptr;
} else {
- attrsFactory->setPersistenceManager(libraryName, libraryFunctionName);
+ attrsFactory->setPersistenceManager(libraryName->c_str(),
+ libraryFunctionName->c_str());
}
- // Free memory allocated in startPersistenceManager, already checked for
- // nullptr
- free(libraryName);
- free(libraryFunctionName);
}
CacheXmlParser::~CacheXmlParser() { GF_SAFE_DELETE(m_cacheCreation); }
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheXmlParser.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheXmlParser.hpp b/src/cppcache/src/CacheXmlParser.hpp
index b86c479..025c83a 100644
--- a/src/cppcache/src/CacheXmlParser.hpp
+++ b/src/cppcache/src/CacheXmlParser.hpp
@@ -55,7 +55,7 @@ typedef PersistenceManager* (*LibraryPersistenceManagerFn)(
class CPPCACHE_EXPORT CacheXmlParser : public CacheXml {
private:
- std::stack<void*> _stack;
+ std::stack<std::shared_ptr<void>> _stack;
xmlSAXHandler m_saxHandler;
CacheXmlCreation* m_cacheCreation;
std::string m_error;
@@ -67,8 +67,9 @@ class CPPCACHE_EXPORT CacheXmlParser : public CacheXml {
bool m_flagAnyOtherException;
bool m_flagExpirationAttribute;
std::map<std::string, RegionAttributesPtr> namedRegions;
- PoolFactory* m_poolFactory;
+ std::shared_ptr<PoolFactory> m_poolFactory;
+ Cache* m_cache;
/** Pool helper */
void setPoolInfo(PoolFactory* poolFactory, const char* name,
const char* value);
@@ -76,9 +77,9 @@ class CPPCACHE_EXPORT CacheXmlParser : public CacheXml {
void handleParserErrors(int res);
public:
- CacheXmlParser();
+ CacheXmlParser(Cache* cache);
~CacheXmlParser();
- static CacheXmlParser* parse(const char* cachexml);
+ static CacheXmlParser* parse(const char* cachexml, Cache* cache);
void parseFile(const char* filename);
void parseMemory(const char* buffer, int size);
void setAttributes(Cache* cache);
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheableEnum.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheableEnum.cpp b/src/cppcache/src/CacheableEnum.cpp
index 7795de5..5e76483 100644
--- a/src/cppcache/src/CacheableEnum.cpp
+++ b/src/cppcache/src/CacheableEnum.cpp
@@ -19,6 +19,7 @@
#include <PdxHelper.hpp>
#include <GeodeTypeIdsImpl.hpp>
#include <EnumInfo.hpp>
+#include "CacheRegionHelper.hpp"
namespace apache {
namespace geode {
@@ -40,8 +41,9 @@ CacheableEnum::CacheableEnum(const char* enumClassName, const char* enumName,
}
void CacheableEnum::toData(apache::geode::client::DataOutput& output) const {
- int enumVal = PdxHelper::getEnumValue(m_enumClassName->asChar(),
- m_enumName->asChar(), m_ordinal);
+ int enumVal = PdxHelper::getEnumValue(
+ m_enumClassName->asChar(), m_enumName->asChar(), m_ordinal,
+ CacheRegionHelper::getCacheImpl(output.getCache())->getPdxTypeRegistry());
output.write(static_cast<int8_t>(GeodeTypeIds::CacheableEnum));
output.write(int8_t(enumVal >> 24));
output.writeArrayLen(enumVal & 0xFFFFFF);
@@ -53,7 +55,9 @@ Serializable* CacheableEnum::fromData(apache::geode::client::DataInput& input) {
int32_t arrLen;
input.readArrayLen(&arrLen);
int enumId = (dsId << 24) | (arrLen & 0xFFFFFF);
- EnumInfoPtr enumVal = PdxHelper::getEnum(enumId);
+ EnumInfoPtr enumVal = PdxHelper::getEnum(
+ enumId,
+ CacheRegionHelper::getCacheImpl(input.getCache())->getPdxTypeRegistry());
m_enumClassName = enumVal->getEnumClassName();
m_enumName = enumVal->getEnumName();
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheableObjectPartList.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheableObjectPartList.hpp b/src/cppcache/src/CacheableObjectPartList.hpp
index cbc241b..35e9d39 100644
--- a/src/cppcache/src/CacheableObjectPartList.hpp
+++ b/src/cppcache/src/CacheableObjectPartList.hpp
@@ -72,6 +72,17 @@ class CacheableObjectPartList : public Cacheable {
m_destroyTracker(0),
m_addToLocalCache(false) {}
+ inline CacheableObjectPartList(ThinClientRegion* region)
+ : m_keys(nullptr),
+ m_keysOffset(nullptr),
+ m_values(nullptr),
+ m_exceptions(nullptr),
+ m_resultKeys(nullptr),
+ m_region(region),
+ m_updateCountMap(nullptr),
+ m_destroyTracker(0),
+ m_addToLocalCache(false) {}
+
// never implemented.
CacheableObjectPartList& operator=(const CacheableObjectPartList& other);
CacheableObjectPartList(const CacheableObjectPartList& other);
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CacheableString.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CacheableString.cpp b/src/cppcache/src/CacheableString.cpp
index 85fac8d..eddba1c 100644
--- a/src/cppcache/src/CacheableString.cpp
+++ b/src/cppcache/src/CacheableString.cpp
@@ -25,6 +25,8 @@
#include <cstdlib>
#include <ace/ACE.h>
#include <ace/OS.h>
+#include "DataOutputInternal.hpp"
+#include "SerializationRegistry.hpp"
using namespace apache::geode::client;
@@ -196,7 +198,7 @@ char* CacheableString::getASCIIString(const wchar_t* value, int32_t& len,
}
len -= clen;
} else {
- DataOutput out;
+ DataOutputInternal out;
const wchar_t* pvalue = value;
while ((currentChar = *pvalue) != 0) {
c = getASCIIChar(currentChar, isASCII, encodedLen);
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ClientMetadata.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ClientMetadata.hpp b/src/cppcache/src/ClientMetadata.hpp
index 37a025e..b6ab281 100644
--- a/src/cppcache/src/ClientMetadata.hpp
+++ b/src/cppcache/src/ClientMetadata.hpp
@@ -20,6 +20,7 @@
* limitations under the License.
*/
+#include <geode/Log.hpp>
#include <geode/PartitionResolver.hpp>
#include "ServerLocation.hpp"
#include "BucketServerLocation.hpp"
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ClientMetadataService.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ClientMetadataService.cpp b/src/cppcache/src/ClientMetadataService.cpp
index 1939f16..20b611f 100644
--- a/src/cppcache/src/ClientMetadataService.cpp
+++ b/src/cppcache/src/ClientMetadataService.cpp
@@ -54,8 +54,12 @@ ClientMetadataService::ClientMetadataService(Pool* pool)
{
m_regionQueue = new Queue<std::string>(false);
m_pool = pool;
- m_bucketWaitTimeout =
- DistributedSystem::getSystemProperties()->bucketWaitTimeout();
+
+ ThinClientPoolDM* tcrdm = dynamic_cast<ThinClientPoolDM*>(m_pool);
+ CacheImpl* cacheImpl = tcrdm->getConnectionManager().getCacheImpl();
+ m_bucketWaitTimeout = cacheImpl->getDistributedSystem()
+ .getSystemProperties()
+ .bucketWaitTimeout();
}
int ClientMetadataService::svc() {
@@ -128,7 +132,11 @@ void ClientMetadataService::getClientPRMetadata(const char* regionFullPath) {
ClientMetadataPtr newCptr = nullptr;
if (cptr == nullptr) {
- TcrMessageGetClientPartitionAttributes request(regionFullPath);
+ TcrMessageGetClientPartitionAttributes request(tcrdm->getConnectionManager()
+ .getCacheImpl()
+ ->getCache()
+ ->createDataOutput(),
+ regionFullPath);
GfErrType err = tcrdm->sendSyncRequest(request, reply);
if (err == GF_NOERR &&
reply.getMessageType() ==
@@ -182,7 +190,11 @@ ClientMetadataPtr ClientMetadataService::SendClientPRMetadata(
throw IllegalArgumentException(
"ClientMetaData: pool cast to ThinClientPoolDM failed");
}
- TcrMessageGetClientPrMetadata request(regionPath);
+ TcrMessageGetClientPrMetadata request(tcrdm->getConnectionManager()
+ .getCacheImpl()
+ ->getCache()
+ ->createDataOutput(),
+ regionPath);
TcrMessageReply reply(true, nullptr);
// send this message to server and get metadata from server.
LOGFINE("Now sending GET_CLIENT_PR_METADATA for getting from server: %s",
@@ -251,10 +263,9 @@ void ClientMetadataService::getBucketServerLocation(
"The RoutingObject returned by PartitionResolver is null.");
}
}
- FixedPartitionResolverPtr fpResolver(
- dynamic_cast<FixedPartitionResolver*>(resolver.get()));
- if (fpResolver != nullptr) {
- const char* partition = fpResolver->getPartitionName(event);
+ if (const auto fpResolver =
+ std::dynamic_pointer_cast<FixedPartitionResolver>(resolver)) {
+ const auto partition = fpResolver->getPartitionName(event);
if (partition == nullptr) {
throw IllegalStateException(
"partition name returned by Partition resolver is null.");
@@ -313,13 +324,13 @@ void ClientMetadataService::enqueueForMetadataRefresh(
"ClientMetaData: pool cast to ThinClientPoolDM failed");
}
RegionPtr region;
- tcrdm->getConnectionManager().getCacheImpl()->getRegion(regionFullPath,
- region);
- LocalRegion* lregion = dynamic_cast<LocalRegion*>(region.get());
+
+ auto cache = tcrdm->getConnectionManager().getCacheImpl();
+ cache->getRegion(regionFullPath, region);
std::string serverGroup = tcrdm->getServerGroup();
if (serverGroup.length() != 0) {
- CacheImpl::setServerGroupFlag(serverGroupFlag);
+ cache->setServerGroupFlag(serverGroupFlag);
if (serverGroupFlag == 2) {
LOGFINER(
"Network hop but, from within same server-group, so no metadata "
@@ -337,7 +348,7 @@ void ClientMetadataService::enqueueForMetadataRefresh(
return;
}
LOGFINE("Network hop so fetching single hop metadata from the server");
- CacheImpl::setNetworkHopFlag(true);
+ cache->setNetworkHopFlag(true);
tcrRegion->setMetaDataRefreshed(true);
std::string* tempRegionPath = new std::string(regionFullPath);
m_regionQueue->put(tempRegionPath);
@@ -855,15 +866,13 @@ bool ClientMetadataService::isBucketMarkedForTimeout(const char* regionFullPath,
ReadGuard guard(m_PRbucketStatusLock);
- std::map<std::string, PRbuckets*>::iterator bs =
- m_bucketStatus.find(regionFullPath);
-
+ const auto& bs = m_bucketStatus.find(regionFullPath);
if (bs != m_bucketStatus.end()) {
bool m = bs->second->isBucketTimedOut(bucketid, m_bucketWaitTimeout);
- if (m == true) {
+ if (m) {
ThinClientPoolDM* tcrdm = dynamic_cast<ThinClientPoolDM*>(m_pool);
CacheImpl* cache = tcrdm->getConnectionManager().getCacheImpl();
- cache->setBlackListBucketTimeouts();
+ cache->incBlackListBucketTimeouts();
}
LOGFINE("isBucketMarkedForTimeout:: for bucket %d returning = %d", bucketid,
m);
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ClientProxyMembershipID.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ClientProxyMembershipID.cpp b/src/cppcache/src/ClientProxyMembershipID.cpp
index 41f0f6e..cbf7d6b 100644
--- a/src/cppcache/src/ClientProxyMembershipID.cpp
+++ b/src/cppcache/src/ClientProxyMembershipID.cpp
@@ -22,8 +22,10 @@
#include <geode/GeodeTypeIds.hpp>
#include "GeodeTypeIdsImpl.hpp"
#include <geode/CacheableBuiltins.hpp>
+#include "DataOutputInternal.hpp"
#include "Version.hpp"
#include <string>
+#include <memory>
#define ADDRSIZE 4
#define DCPORT 12334
@@ -50,73 +52,9 @@ static class RandomInitializer {
} oneTimeRandomInitializer;
} // namespace
-std::string ClientProxyMembershipID::g_dsName("DSName");
-std::string ClientProxyMembershipID::g_randString("GFNative");
-#define RAND_STRING_LEN 10
const int ClientProxyMembershipID::VERSION_MASK = 0x8;
const int8_t ClientProxyMembershipID::TOKEN_ORDINAL = -1;
-// initialize random string data and DistributedSystem name
-void ClientProxyMembershipID::init(const std::string& dsName) {
- if (dsName.size() > 0) {
- const char selectChars[] =
- "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
- const uint32_t numChars = (sizeof(selectChars) / sizeof(char)) - 1;
-
- g_dsName = dsName;
- bool randDone = false;
- char randString[RAND_STRING_LEN + 1];
- int pid = ACE_OS::getpid();
- // try /dev/urandom first
- FILE* urandom = ACE_OS::fopen("/dev/urandom", "rb");
- if (urandom) {
- LOGFINE("Opened /dev/urandom for ClientProxyMembershipID random data");
- uint8_t readBytes[RAND_STRING_LEN];
- size_t readLen = ACE_OS::fread(readBytes, RAND_STRING_LEN, 1, urandom);
- if (readLen == 1) {
- for (uint32_t index = 0; index < RAND_STRING_LEN; ++index) {
- randString[index] = selectChars[readBytes[index] % numChars];
- }
- randString[RAND_STRING_LEN] = '\0';
- randDone = true;
- }
- ACE_OS::fclose(urandom);
- }
- if (!randDone) {
- for (uint32_t index = 0; index < RAND_STRING_LEN; ++index) {
- randString[index] = selectChars[ACE_OS::rand() % numChars];
- }
- randString[RAND_STRING_LEN] = '\0';
- }
- char ps[15] = {0};
- ACE_OS::snprintf(ps, 15, "%d", pid);
- g_randString = "GFNative_";
- g_randString.append(randString).append(ps);
- LOGINFO("Using %s as random data for ClientProxyMembershipID",
- g_randString.c_str());
- }
-}
-const std::string& ClientProxyMembershipID::getRandStringId() {
- return g_randString;
-}
-/*
-// Commenting this function as this is not getting used anywhere.
-ClientProxyMembershipID::ClientProxyMembershipID(const char *durableClientId,
- const uint32_t
-durableClntTimeOut)
-{
- if( durableClientId != nullptr && durableClntTimeOut != 0 ) {
- DataOutput m_memID;
- m_memID.write((int8_t)GeodeTypeIds::CacheableASCIIString);
- m_memID.writeASCII(durableClientId);
- CacheableInt32Ptr int32ptr = CacheableInt32::create(durableClntTimeOut);
- int32ptr->toData(m_memID);
- uint32_t len;
- char* buf = (char*)m_memID.getBuffer(&len);
- m_memIDStr.append(buf, len);
- }
-}
-*/
ClientProxyMembershipID::ClientProxyMembershipID()
: m_hostPort(0),
m_hostAddr(nullptr)
@@ -133,13 +71,14 @@ ClientProxyMembershipID::~ClientProxyMembershipID() {
}
ClientProxyMembershipID::ClientProxyMembershipID(
- const char* hostname, uint32_t hostAddr, uint32_t hostPort,
- const char* durableClientId, const uint32_t durableClntTimeOut) {
+ std::string dsName, std::string randString, const char* hostname,
+ uint32_t hostAddr, uint32_t hostPort, const char* durableClientId,
+ const uint32_t durableClntTimeOut)
+ : m_hostAddrAsUInt32(hostAddr) {
int32_t vmPID = ACE_OS::getpid();
-
- initObjectVars(hostname, reinterpret_cast<uint8_t*>(&hostAddr), 4, false,
- hostPort, durableClientId, durableClntTimeOut, DCPORT, vmPID,
- VMKIND, 0, g_dsName.c_str(), g_randString.c_str(), 0);
+ initObjectVars(hostname, reinterpret_cast<uint8_t*>(&m_hostAddrAsUInt32), 4,
+ false, hostPort, durableClientId, durableClntTimeOut, DCPORT,
+ vmPID, VMKIND, 0, dsName.c_str(), randString.c_str(), 0);
}
// This is only for unit tests and should not be used for any other purpose. See
@@ -157,7 +96,7 @@ void ClientProxyMembershipID::initObjectVars(
const uint32_t durableClntTimeOut, int32_t dcPort, int32_t vPID,
int8_t vmkind, int8_t splitBrainFlag, const char* dsname,
const char* uniqueTag, uint32_t vmViewId) {
- DataOutput m_memID;
+ DataOutputInternal m_memID;
if (dsname == nullptr) {
m_dsname = std::string("");
} else {
@@ -212,9 +151,7 @@ void ClientProxyMembershipID::initObjectVars(
char PID[15] = {0};
char Synch_Counter[15] = {0};
- // ACE_OS::snprintf(PID, 15, "%d",vPID);
ACE_OS::itoa(vPID, PID, 10);
- // ACE_OS::snprintf(Synch_Counter, 15, "%d",synch_counter);
ACE_OS::itoa(synch_counter, Synch_Counter, 10);
clientID.append(hostname);
clientID.append("(");
@@ -273,74 +210,6 @@ const std::string& ClientProxyMembershipID::getDSMemberIdForThinClientUse() {
std::string ClientProxyMembershipID::getHashKey() { return m_hashKey; }
-void ClientProxyMembershipID::getClientProxyMembershipID() {
- // Implement LonerDistributionManager::generateMemberId() and store result in
- // dsMemberId,dsMemberIdLength
- const char* hex = "0123456789ABCDEF";
- std::string DSMemberId = "";
- ACE_TCHAR host[MAXHOSTNAMELEN];
- std::string hostName = " ";
- char buf[50];
- char dsName[50];
- DistributedSystemPtr dsPtr;
- dsPtr = DistributedSystem::getInstance();
-
- ACE_OS::hostname(host, sizeof(host) - 1);
- hostName = host;
- pid_t pid;
- pid = ACE_OS::getpid();
-
- /* adongre
- * CID 28814: Resource leak (RESOURCE_LEAK)
- * Following allocation is not used anywhere
- * commenting the same.
- */
-
- /*int* random = new int[8];
- for (int i = 0; i < 8; i++) {
- random[i]=ACE_OS::rand()%16;
- } */
- char* hname = host;
-
- // ACE_OS::sprintf(hname,"%s",hostName);
- uint32_t len = static_cast<uint32_t>(hostName.length());
- DataOutput m_dsmemID;
- m_dsmemID.writeBytesOnly(reinterpret_cast<int8_t*>(hname), len);
- // DSMemberId = DSMemberId.append(host);
- // DSMemberId= DSMemberId.append("(");
- m_dsmemID.write(static_cast<int8_t>('('));
- int lenPid = ACE_OS::snprintf(buf, 50, "%d", pid);
- // DSMemberId.append(buf);
- // m_dsmemID.writeInt((int32_t)pid);
- m_dsmemID.writeBytesOnly(reinterpret_cast<int8_t*>(buf), lenPid);
- // DSMemberId.append("):");
- m_dsmemID.write(static_cast<int8_t>(')'));
- m_dsmemID.write(static_cast<int8_t>(':'));
-
- char hexBuf[20];
- for (int j = 0; j < 8; j++) {
- // Hardcoding random number for Thin Client
- // hexBuf[j] = hex[random[j]%16];
- hexBuf[j] = hex[1];
- }
- // DSMemberId = DSMemberId.append(hexBuf);
- m_dsmemID.writeBytesOnly(reinterpret_cast<int8_t*>(hexBuf), 8);
- m_dsmemID.write(static_cast<int8_t>(':'));
- // DSMemberId = DSMemberId.append(":");
- ACE_OS::snprintf(dsName, 50, "%s", dsPtr->getName());
- // DSMemberId.append(dsName);
- uint32_t dsLen = static_cast<uint32_t>(strlen(dsName));
- m_dsmemID.writeBytesOnly(reinterpret_cast<int8_t*>(dsName), dsLen);
- m_dsmemIDStr += (char*)m_dsmemID.getBuffer();
- uint32_t strLen;
- char* strBuf = (char*)m_dsmemID.getBuffer(&strLen);
- m_dsmemIDStr.append(strBuf, strLen);
- // dsMemberIdLength = DSMemberId.length();
- // dsMemberId= (char*)ACE_OS::malloc(dsMemberIdLength+1);
- // ACE_OS::strcpy(dsMemberId,DSMemberId.c_str());
- // return m_dsmemID;
-}
-
void ClientProxyMembershipID::toData(DataOutput& output) const {
throw IllegalStateException("Member ID toData() not implemented.");
}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ClientProxyMembershipID.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ClientProxyMembershipID.hpp b/src/cppcache/src/ClientProxyMembershipID.hpp
index d7a29c9..4e86423 100644
--- a/src/cppcache/src/ClientProxyMembershipID.hpp
+++ b/src/cppcache/src/ClientProxyMembershipID.hpp
@@ -37,7 +37,9 @@ class ClientProxyMembershipID : public DSMemberForVersionStamp {
public:
const char* getDSMemberId(uint32_t& mesgLength) const;
const char* getDSMemberIdForCS43(uint32_t& mesgLength) const;
- ClientProxyMembershipID(const char* hostname, uint32_t hostAddr,
+
+ ClientProxyMembershipID(std::string dsName, std::string randString,
+ const char* hostname, uint32_t hostAddr,
uint32_t hostPort,
const char* durableClientId = nullptr,
const uint32_t durableClntTimeOut = 0);
@@ -51,11 +53,6 @@ class ClientProxyMembershipID : public DSMemberForVersionStamp {
// uint32_t durableClntTimeOut = 0);
ClientProxyMembershipID();
~ClientProxyMembershipID();
- void getClientProxyMembershipID();
- // Initialize for random data and set the DS name.
- // This method is not thread-safe.
- static void init(const std::string& dsName);
- static const std::string& getRandStringId();
static void increaseSynchCounter();
static Serializable* createDeserializable() {
return new ClientProxyMembershipID();
@@ -111,15 +108,13 @@ class ClientProxyMembershipID : public DSMemberForVersionStamp {
private:
std::string m_memIDStr;
std::string m_dsmemIDStr;
- // static data
- static std::string g_dsName;
- static std::string g_randString;
std::string clientID;
std::string m_dsname;
uint32_t m_hostPort;
uint8_t* m_hostAddr;
uint32_t m_hostAddrLen;
+ uint32_t m_hostAddrAsUInt32;
std::string m_uniqueTag;
std::string m_hashKey;
bool m_hostAddrLocalMem;
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ClientProxyMembershipIDFactory.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ClientProxyMembershipIDFactory.cpp b/src/cppcache/src/ClientProxyMembershipIDFactory.cpp
new file mode 100644
index 0000000..f9bf982
--- /dev/null
+++ b/src/cppcache/src/ClientProxyMembershipIDFactory.cpp
@@ -0,0 +1,44 @@
+#include <algorithm>
+#include <iterator>
+#include <random>
+
+#include "ClientProxyMembershipIDFactory.hpp"
+
+namespace apache {
+namespace geode {
+namespace client {
+
+ClientProxyMembershipIDFactory::ClientProxyMembershipIDFactory(
+ std::string dsName)
+ : dsName(dsName) {
+ static const auto alphabet =
+ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
+ static const auto numChars = (sizeof(alphabet) / sizeof(char)) - 2;
+
+ std::random_device rd;
+ std::default_random_engine rng(rd());
+ std::uniform_int_distribution<> dist(0, numChars);
+
+ randString.reserve(7 + 10 + 15);
+ randString.append("Native_");
+ std::generate_n(std::back_inserter(randString), 10,
+ [&]() { return alphabet[dist(rng)]; });
+
+ auto pid = ACE_OS::getpid();
+ randString.append(std::to_string(pid));
+
+ LOGINFO("Using %s as random data for ClientProxyMembershipID",
+ randString.c_str());
+}
+
+std::unique_ptr<ClientProxyMembershipID> ClientProxyMembershipIDFactory::create(
+ const char* hostname, uint32_t hostAddr, uint32_t hostPort,
+ const char* durableClientId, const uint32_t durableClntTimeOut) {
+ return std::unique_ptr<ClientProxyMembershipID>(new ClientProxyMembershipID(
+ dsName, randString, hostname, hostAddr, hostPort, durableClientId,
+ durableClntTimeOut));
+}
+
+} // namespace client
+} // namespace geode
+} // namespace apache
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ClientProxyMembershipIDFactory.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ClientProxyMembershipIDFactory.hpp b/src/cppcache/src/ClientProxyMembershipIDFactory.hpp
new file mode 100644
index 0000000..a24abbf
--- /dev/null
+++ b/src/cppcache/src/ClientProxyMembershipIDFactory.hpp
@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#ifndef GEODE_CLIENTPROXYMEMBERSHIPIDFACTORY_H_
+#define GEODE_CLIENTPROXYMEMBERSHIPIDFACTORY_H_
+
+#include <string>
+
+#include "ClientProxyMembershipID.hpp"
+
+namespace apache {
+namespace geode {
+namespace client {
+
+class ClientProxyMembershipIDFactory {
+ public:
+ ClientProxyMembershipIDFactory(std::string dsName);
+
+ std::unique_ptr<ClientProxyMembershipID> create(
+ const char* hostname, uint32_t hostAddr, uint32_t hostPort,
+ const char* durableClientId = nullptr,
+ const uint32_t durableClntTimeOut = 0);
+
+ private:
+ std::string dsName;
+ std::string randString;
+};
+
+} // namespace client
+} // namespace geode
+} // namespace apache
+
+#endif // GEODE_CLIENTPROXYMEMBERSHIPID_H_
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ConcurrentEntriesMap.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ConcurrentEntriesMap.cpp b/src/cppcache/src/ConcurrentEntriesMap.cpp
index c79d4c2..c8338be 100644
--- a/src/cppcache/src/ConcurrentEntriesMap.cpp
+++ b/src/cppcache/src/ConcurrentEntriesMap.cpp
@@ -24,19 +24,17 @@ using namespace apache::geode::client;
bool EntriesMap::boolVal = false;
-ConcurrentEntriesMap::ConcurrentEntriesMap(EntryFactory* entryFactory,
- bool concurrencyChecksEnabled,
- RegionInternal* region,
- uint8_t concurrency)
- : EntriesMap(entryFactory),
+ConcurrentEntriesMap::ConcurrentEntriesMap(
+ ExpiryTaskManager* expiryTaskManager,
+ std::unique_ptr<EntryFactory> entryFactory, bool concurrencyChecksEnabled,
+ RegionInternal* region, uint8_t concurrency)
+ : EntriesMap(std::move(entryFactory)),
+ m_expiryTaskManager(expiryTaskManager),
m_concurrency(0),
m_segments((MapSegment*)0),
m_size(0),
m_region(region),
m_numDestroyTrackers(0),
- /* adongre
- * CID 28929: Uninitialized pointer field (UNINIT_CTOR)
- */
m_concurrencyChecksEnabled(concurrencyChecksEnabled) {
GF_DEV_ASSERT(entryFactory != nullptr);
@@ -52,8 +50,9 @@ void ConcurrentEntriesMap::open(uint32_t initialCapacity) {
uint32_t segSize = 1 + (initialCapacity - 1) / m_concurrency;
m_segments = new MapSegment[m_concurrency];
for (int index = 0; index < m_concurrency; ++index) {
- m_segments[index].open(m_region, this->getEntryFactory(), segSize,
- &m_numDestroyTrackers, m_concurrencyChecksEnabled);
+ m_segments[index].open(m_region, getEntryFactory(), m_expiryTaskManager,
+ segSize, &m_numDestroyTrackers,
+ m_concurrencyChecksEnabled);
}
}
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ConcurrentEntriesMap.hpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/ConcurrentEntriesMap.hpp b/src/cppcache/src/ConcurrentEntriesMap.hpp
index 94e6a34..0a67fbb 100644
--- a/src/cppcache/src/ConcurrentEntriesMap.hpp
+++ b/src/cppcache/src/ConcurrentEntriesMap.hpp
@@ -1,8 +1,3 @@
-#pragma once
-
-#ifndef GEODE_CONCURRENTENTRIESMAP_H_
-#define GEODE_CONCURRENTENTRIESMAP_H_
-
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
@@ -20,7 +15,12 @@
* limitations under the License.
*/
+#pragma once
+
+#ifndef GEODE_CONCURRENTENTRIESMAP_H_
+#define GEODE_CONCURRENTENTRIESMAP_H_
#include <atomic>
+
#include <geode/geode_globals.hpp>
#include "EntriesMap.hpp"
#include "MapSegment.hpp"
@@ -38,6 +38,7 @@ class RegionInternal;
*/
class CPPCACHE_EXPORT ConcurrentEntriesMap : public EntriesMap {
protected:
+ ExpiryTaskManager* m_expiryTaskManager;
uint8_t m_concurrency;
MapSegment* m_segments;
std::atomic<uint32_t> m_size;
@@ -70,7 +71,8 @@ class CPPCACHE_EXPORT ConcurrentEntriesMap : public EntriesMap {
/**
* @brief constructor, must call open before using map.
*/
- ConcurrentEntriesMap(EntryFactory* entryFactory,
+ ConcurrentEntriesMap(ExpiryTaskManager* expiryTaskManager,
+ std::unique_ptr<EntryFactory> entryFactory,
bool concurrencyChecksEnabled, RegionInternal* region,
uint8_t concurrency = 16);
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CppCacheLibrary.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CppCacheLibrary.cpp b/src/cppcache/src/CppCacheLibrary.cpp
index ea77dbb..c9c1fd9 100644
--- a/src/cppcache/src/CppCacheLibrary.cpp
+++ b/src/cppcache/src/CppCacheLibrary.cpp
@@ -33,7 +33,6 @@
#include <geode/DataOutput.hpp>
#include "TcrMessage.hpp"
#include "Utils.hpp"
-#include "PdxTypeRegistry.hpp"
#include <string>
@@ -57,12 +56,6 @@ CppCacheLibrary::CppCacheLibrary() {
// Put initialization code for statics and other such things here.
try {
gf_log_libinit();
- EntryFactory::init();
- LRUEntryFactory::init();
- ExpEntryFactory::init();
- LRUExpEntryFactory::init();
- CacheFactory::init();
- SerializationRegistry::init();
// PdxTypeRegistry::init();
// log( "Finished initializing CppCacheLibrary." );
} catch (apache::geode::client::Exception& ge) {
@@ -73,7 +66,6 @@ CppCacheLibrary::CppCacheLibrary() {
CppCacheLibrary::~CppCacheLibrary() {
// Put any global clean up code here.
- CacheFactory::cleanup();
// PdxTypeRegistry::cleanup();
ACE::fini();
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/CqEventImpl.cpp
----------------------------------------------------------------------
diff --git a/src/cppcache/src/CqEventImpl.cpp b/src/cppcache/src/CqEventImpl.cpp
index 8d15bd0..050c9cd 100644
--- a/src/cppcache/src/CqEventImpl.cpp
+++ b/src/cppcache/src/CqEventImpl.cpp
@@ -68,7 +68,11 @@ CacheablePtr CqEventImpl::getNewValue() const {
return m_newValue;
} else {
// Get full object for delta
- TcrMessageRequestEventValue fullObjectMsg(m_eventId);
+ TcrMessageRequestEventValue fullObjectMsg(m_tcrdm->getConnectionManager()
+ .getCacheImpl()
+ ->getCache()
+ ->createDataOutput(),
+ m_eventId);
TcrMessageReply reply(true, nullptr);
ThinClientPoolHADM* poolHADM = dynamic_cast<ThinClientPoolHADM*>(m_tcrdm);
GfErrType err = GF_NOTCON;