http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/PoolManager.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PoolManager.cpp b/src/cppcache/src/PoolManager.cpp index 49a6425..7ad036b 100644 --- a/src/cppcache/src/PoolManager.cpp +++ b/src/cppcache/src/PoolManager.cpp @@ -14,84 +14,116 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include <mutex> + #include <geode/PoolManager.hpp> -#include <ace/Recursive_Thread_Mutex.h> -#include <ace/Guard_T.h> using namespace apache::geode::client; -// TODO: make this a member of TcrConnectionManager. -HashMapOfPools* connectionPools = nullptr; /*new HashMapOfPools( )*/ -ACE_Recursive_Thread_Mutex connectionPoolsLock; +class PoolManager::Impl { + public: + Impl(const Cache& cache) : m_cache(cache) {} + void removePool(const char* name); -void removePool(const char* name) { - ACE_Guard<ACE_Recursive_Thread_Mutex> guard(connectionPoolsLock); - connectionPools->erase(name); -} + PoolFactoryPtr createFactory(); -PoolFactoryPtr PoolManager::createFactory() { - if (connectionPools == nullptr) { - ACE_Guard<ACE_Recursive_Thread_Mutex> guard(connectionPoolsLock); - if (connectionPools == nullptr) { - connectionPools = new HashMapOfPools(); - } - } - return PoolFactoryPtr(new PoolFactory()); + void close(bool keepAlive); + + PoolPtr find(const char* name); + + PoolPtr find(RegionPtr region); + + const HashMapOfPools& getAll(); + + void addPool(const char* name, const PoolPtr& pool); + + PoolPtr getDefaultPool(); + + private: + HashMapOfPools m_connectionPools; + std::recursive_mutex m_connectionPoolsLock; + PoolPtr m_defaultPool; + const Cache& m_cache; +}; + +void PoolManager::Impl::removePool(const char* name) { + std::lock_guard<std::recursive_mutex> guard(m_connectionPoolsLock); + m_connectionPools.erase(name); } -void PoolManager::close(bool keepAlive) { - ACE_Guard<ACE_Recursive_Thread_Mutex> guard(connectionPoolsLock); +PoolFactoryPtr PoolManager::Impl::createFactory() { + return std::shared_ptr<PoolFactory>(new PoolFactory(m_cache)); +} - if (connectionPools == nullptr) { - return; - } +void PoolManager::Impl::close(bool keepAlive) { + std::lock_guard<std::recursive_mutex> guard(m_connectionPoolsLock); std::vector<PoolPtr> poolsList; - for (const auto& c : *connectionPools) { + for (const auto& c : m_connectionPools) { poolsList.push_back(c.second); } for (const auto& iter : poolsList) { iter->destroy(keepAlive); } - - GF_SAFE_DELETE(connectionPools); } -PoolPtr PoolManager::find(const char* name) { - ACE_Guard<ACE_Recursive_Thread_Mutex> guard(connectionPoolsLock); - - if (connectionPools == nullptr) { - connectionPools = new HashMapOfPools(); - } +PoolPtr PoolManager::Impl::find(const char* name) { + std::lock_guard<std::recursive_mutex> guard(m_connectionPoolsLock); if (name) { - const auto& iter = connectionPools->find(name); + const auto& iter = m_connectionPools.find(name); PoolPtr poolPtr = nullptr; - if (iter != connectionPools->end()) { + if (iter != m_connectionPools.end()) { poolPtr = iter->second; GF_DEV_ASSERT(poolPtr != nullptr); } return poolPtr; } else { - return nullptr; + return m_connectionPools.empty() ? nullptr + : m_connectionPools.begin()->second; } } -PoolPtr PoolManager::find(RegionPtr region) { +PoolPtr PoolManager::Impl::find(RegionPtr region) { return find(region->getAttributes()->getPoolName()); } -const HashMapOfPools& PoolManager::getAll() { - if (connectionPools == nullptr) { - ACE_Guard<ACE_Recursive_Thread_Mutex> guard(connectionPoolsLock); - if (connectionPools == nullptr) { - connectionPools = new HashMapOfPools(); - } +const HashMapOfPools& PoolManager::Impl::getAll() { return m_connectionPools; } + +void PoolManager::Impl::addPool(const char* name, const PoolPtr& pool) { + std::lock_guard<std::recursive_mutex> guard(m_connectionPoolsLock); + + if (!m_defaultPool) { + m_defaultPool = pool; } - return *connectionPools; + + m_connectionPools.emplace(name, pool); } + +PoolPtr PoolManager::Impl::getDefaultPool() { return m_defaultPool; } + +PoolManager::PoolManager(const Cache& cache) + : m_pimpl(new Impl(cache), [](Impl* impl) { delete impl; }) {} + +void PoolManager::removePool(const char* name) { m_pimpl->removePool(name); } + +PoolFactoryPtr PoolManager::createFactory() { return m_pimpl->createFactory(); } + +void PoolManager::close(bool keepAlive) { m_pimpl->close(keepAlive); } + +PoolPtr PoolManager::find(const char* name) { return m_pimpl->find(name); } + +PoolPtr PoolManager::find(RegionPtr region) { return m_pimpl->find(region); } + +const HashMapOfPools& PoolManager::getAll() { return m_pimpl->getAll(); } + +void PoolManager::addPool(const char* name, const PoolPtr& pool) { + m_pimpl->addPool(name, pool); +} + +PoolPtr PoolManager::getDefaultPool() { return m_pimpl->getDefaultPool(); }
http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/PoolStatistics.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PoolStatistics.cpp b/src/cppcache/src/PoolStatistics.cpp index 9aa477a..e5f5188 100644 --- a/src/cppcache/src/PoolStatistics.cpp +++ b/src/cppcache/src/PoolStatistics.cpp @@ -36,233 +36,136 @@ using statistics::StatisticsFactory; using statistics::StatisticsManager; using util::concurrent::spinlock_mutex; -//////////////////////////////////////////////////////////////////////////////// - -PoolStatType* PoolStatType::single = nullptr; -spinlock_mutex PoolStatType::m_singletonLock; -spinlock_mutex PoolStatType::m_statTypeLock; - -void PoolStatType::clean() { - std::lock_guard<spinlock_mutex> guard(m_singletonLock); - if (single) { - delete single; - single = nullptr; - } -} - -StatisticsType* PoolStatType::getStatType() { - std::lock_guard<spinlock_mutex> guard(m_statTypeLock); - StatisticsFactory* factory = StatisticsFactory::getExistingInstance(); - GF_D_ASSERT(!!factory); +constexpr const char* PoolStats::STATS_NAME; +constexpr const char* PoolStats::STATS_DESC; - StatisticsType* statsType = factory->findType("PoolStatistics"); +PoolStats::PoolStats(StatisticsFactory* factory, const std::string& poolName) { + auto statsType = factory->findType(STATS_NAME); if (statsType == nullptr) { - m_stats[0] = factory->createIntGauge( + auto stats = new StatisticDescriptor*[27]; + + stats[0] = factory->createIntGauge( "locators", "Current number of locators discovered", "locators"); - m_stats[1] = factory->createIntGauge( + stats[1] = factory->createIntGauge( "servers", "Current number of servers discovered", "servers"); - m_stats[2] = factory->createIntGauge( + stats[2] = factory->createIntGauge( "subscriptionServers", "Number of servers hosting this clients subscriptions", "servers"); - m_stats[3] = factory->createLongCounter( + stats[3] = factory->createLongCounter( "locatorRequests", "Number of requests from this connection pool to a locator", "requests"); - m_stats[4] = factory->createLongCounter( + stats[4] = factory->createLongCounter( "locatorResponses", "Number of responses from the locator to this connection pool", "responses"); - m_stats[5] = factory->createIntGauge( + stats[5] = factory->createIntGauge( "poolConnections", "Current number of pool connections", "connections"); - m_stats[6] = factory->createIntCounter( + stats[6] = factory->createIntCounter( "connects", "Total number of times a connection has been created.", "connects"); - m_stats[7] = factory->createIntCounter( + stats[7] = factory->createIntCounter( "disconnects", "Total number of times a connection has been destroyed.", "disconnects"); - m_stats[8] = factory->createIntCounter( + stats[8] = factory->createIntCounter( "minPoolSizeConnects", "Total number of connects done to maintain minimum pool size.", "connects"); - m_stats[9] = factory->createIntCounter( + stats[9] = factory->createIntCounter( "loadConditioningConnects", "Total number of connects done due to load conditioning.", "connects"); - m_stats[10] = factory->createIntCounter( + stats[10] = factory->createIntCounter( "idleDisconnects", "Total number of disconnects done due to idle expiration.", "disconnects"); - m_stats[11] = factory->createIntCounter( + stats[11] = factory->createIntCounter( "loadConditioningDisconnects", "Total number of disconnects done due to load conditioning expiration.", "disconnects"); - m_stats[12] = factory->createIntGauge( + stats[12] = factory->createIntGauge( "connectionWaitsInProgress", "Current number of threads waiting for a connection", "threads"); - m_stats[13] = factory->createIntCounter( + stats[13] = factory->createIntCounter( "connectionWaits", "Total number of times a thread completed waiting for a connection (by " "timing out or by getting a connection).", "waits"); - m_stats[14] = factory->createLongCounter( + stats[14] = factory->createLongCounter( "connectionWaitTime", "Total time (nanoseconds) spent waiting for a connection.", "nanoseconds"); - m_stats[15] = factory->createIntGauge( + stats[15] = factory->createIntGauge( "clientOpsInProgress", "Current number of clientOps being executed", "clientOps"); - m_stats[16] = factory->createIntCounter( + stats[16] = factory->createIntCounter( "clientOps", "Total number of clientOps completed successfully", "clientOps"); - m_stats[17] = factory->createLongCounter( + stats[17] = factory->createLongCounter( "clientOpTime", "Total amount of time, in nanoseconds spent doing clientOps", "nanoseconds"); - m_stats[18] = factory->createIntCounter( + stats[18] = factory->createIntCounter( "clientOpFailures", "Total number of clientOp attempts that have failed", "clientOps"); - m_stats[19] = factory->createIntCounter( + stats[19] = factory->createIntCounter( "clientOpTimeouts", "Total number of clientOp attempts that have timed out", "clientOps"); - m_stats[20] = factory->createLongCounter( + stats[20] = factory->createLongCounter( "receivedBytes", "Total number of bytes received from the server.", "bytes"); - m_stats[21] = factory->createLongCounter( + stats[21] = factory->createLongCounter( "messagesBeingReceived", "Total number of message being received off the network.", "messages"); - m_stats[22] = factory->createLongCounter( + stats[22] = factory->createLongCounter( "processedDeltaMessages", "Total number of delta message processed successfully", "messages"); - m_stats[23] = factory->createLongCounter( + stats[23] = factory->createLongCounter( "deltaMessageFailures", "Total number of failures in processing delta", "messages"); - m_stats[24] = factory->createLongCounter( + stats[24] = factory->createLongCounter( "processedDeltaMessagesTime", "Total time spent while processing Delta", "nanoseconds"); - m_stats[25] = factory->createIntCounter("queryExecutions", - "Total number of queryExecutions", - "queryExecutions"); - m_stats[26] = factory->createLongCounter( + stats[25] = factory->createIntCounter("queryExecutions", + "Total number of queryExecutions", + "queryExecutions"); + stats[26] = factory->createLongCounter( "queryExecutionTime", "Total time spent while processing queryExecution", "nanoseconds"); - statsType = factory->createType("PoolStatistics", - "Statistics for this pool", m_stats, 27); - - m_locatorsId = statsType->nameToId("locators"); - m_serversId = statsType->nameToId("servers"); - m_subsServsId = statsType->nameToId("subscriptionServers"); - m_locReqsId = statsType->nameToId("locatorRequests"); - m_locRespsId = statsType->nameToId("locatorResponses"); - m_poolConnsId = statsType->nameToId("poolConnections"); - m_connectsId = statsType->nameToId("connects"); - m_disconnectsId = statsType->nameToId("disconnects"); - m_minPoolConnectsId = statsType->nameToId("minPoolSizeConnects"); - m_loadCondConnectsId = statsType->nameToId("loadConditioningConnects"); - m_idleDisconnectsId = statsType->nameToId("idleDisconnects"); - m_loadCondDisconnectsId = - statsType->nameToId("loadConditioningDisconnects"); - m_waitingConnectionsId = statsType->nameToId("connectionWaitsInProgress"); - m_totalWaitingConnsId = statsType->nameToId("connectionWaits"); - m_totalWaitingConnTimeId = statsType->nameToId("connectionWaitTime"); - m_curClientOpsId = statsType->nameToId("clientOpsInProgress"); - m_clientOpsSuccessId = statsType->nameToId("clientOps"); - m_clientOpsSuccessTimeId = statsType->nameToId("clientOpTime"); - m_clientOpsFailedId = statsType->nameToId("clientOpFailures"); - m_clientOpsTimeoutId = statsType->nameToId("clientOpTimeouts"); - m_receivedBytesId = statsType->nameToId("receivedBytes"); - m_messagesBeingReceivedId = statsType->nameToId("messagesBeingReceived"); - m_processedDeltaMessagesId = statsType->nameToId("processedDeltaMessages"); - m_deltaMessageFailuresId = statsType->nameToId("deltaMessageFailures"); - m_processedDeltaMessagesTimeId = - statsType->nameToId("processedDeltaMessagesTime"); - m_queryExecutionsId = statsType->nameToId("queryExecutions"); - m_queryExecutionTimeId = statsType->nameToId("queryExecutionTime"); - } - - return statsType; -} - -PoolStatType* PoolStatType::getInstance() { - std::lock_guard<spinlock_mutex> guard(m_singletonLock); - if (!single) { - single = new PoolStatType(); + statsType = factory->createType(STATS_NAME, STATS_DESC, stats, 27); } - return single; -} - -PoolStatType::PoolStatType() - : m_locatorsId(0), - m_serversId(0), - m_subsServsId(0), - m_locReqsId(0), - m_locRespsId(0), - m_poolConnsId(0), - m_connectsId(0), - m_disconnectsId(0), - m_minPoolConnectsId(0), - m_loadCondConnectsId(0), - m_idleDisconnectsId(0), - m_loadCondDisconnectsId(0), - m_waitingConnectionsId(0), - m_totalWaitingConnsId(0), - m_totalWaitingConnTimeId(0), - m_curClientOpsId(0), - m_clientOpsSuccessId(0), - m_clientOpsSuccessTimeId(0), - m_clientOpsFailedId(0), - m_clientOpsTimeoutId(0), - m_receivedBytesId(0), - m_messagesBeingReceivedId(0), - m_processedDeltaMessagesId(0), - m_deltaMessageFailuresId(0), - m_processedDeltaMessagesTimeId(0), - m_queryExecutionsId(0), - m_queryExecutionTimeId(0) { - memset(m_stats, 0, sizeof(m_stats)); -} - -//////////////////////////////////////////////////////////////////////////////// - -PoolStats::PoolStats(const char* poolName) { - PoolStatType* poolStatType = PoolStatType::getInstance(); - - StatisticsType* statsType = poolStatType->getStatType(); - - GF_D_ASSERT(statsType != nullptr); - - StatisticsFactory* factory = StatisticsFactory::getExistingInstance(); + m_locatorsId = statsType->nameToId("locators"); + m_serversId = statsType->nameToId("servers"); + m_subsServsId = statsType->nameToId("subscriptionServers"); + m_locReqsId = statsType->nameToId("locatorRequests"); + m_locRespsId = statsType->nameToId("locatorResponses"); + m_poolConnsId = statsType->nameToId("poolConnections"); + m_connectsId = statsType->nameToId("connects"); + m_disconnectsId = statsType->nameToId("disconnects"); + m_minPoolConnectsId = statsType->nameToId("minPoolSizeConnects"); + m_loadCondConnectsId = statsType->nameToId("loadConditioningConnects"); + m_idleDisconnectsId = statsType->nameToId("idleDisconnects"); + m_loadCondDisconnectsId = statsType->nameToId("loadConditioningDisconnects"); + m_waitingConnectionsId = statsType->nameToId("connectionWaitsInProgress"); + m_totalWaitingConnsId = statsType->nameToId("connectionWaits"); + m_totalWaitingConnTimeId = statsType->nameToId("connectionWaitTime"); + m_curClientOpsId = statsType->nameToId("clientOpsInProgress"); + m_clientOpsSuccessId = statsType->nameToId("clientOps"); + m_clientOpsSuccessTimeId = statsType->nameToId("clientOpTime"); + m_clientOpsFailedId = statsType->nameToId("clientOpFailures"); + m_clientOpsTimeoutId = statsType->nameToId("clientOpTimeouts"); + m_receivedBytesId = statsType->nameToId("receivedBytes"); + m_messagesBeingReceivedId = statsType->nameToId("messagesBeingReceived"); + m_processedDeltaMessagesId = statsType->nameToId("processedDeltaMessages"); + m_deltaMessageFailuresId = statsType->nameToId("deltaMessageFailures"); + m_processedDeltaMessagesTimeId = + statsType->nameToId("processedDeltaMessagesTime"); + m_queryExecutionsId = statsType->nameToId("queryExecutions"); + m_queryExecutionTimeId = statsType->nameToId("queryExecutionTime"); - m_poolStats = factory->createAtomicStatistics(statsType, poolName); + m_poolStats = factory->createAtomicStatistics(statsType, poolName.c_str()); - m_locatorsId = poolStatType->getLocatorsId(); - m_serversId = poolStatType->getServersId(); - m_subsServsId = poolStatType->getSubscriptionServersId(); - m_locReqsId = poolStatType->getLocatorRequestsId(); - m_locRespsId = poolStatType->getLocatorResposesId(); - m_poolConnsId = poolStatType->getPoolConnectionsId(); - m_connectsId = poolStatType->getConnectsId(); - m_disconnectsId = poolStatType->getDisconnectsId(); - m_minPoolConnectsId = poolStatType->getMinPoolSizeConnectsId(); - m_loadCondConnectsId = poolStatType->getLoadCondConnectsId(); - m_idleDisconnectsId = poolStatType->getIdleDisconnectsId(); - m_loadCondDisconnectsId = poolStatType->getLoadCondDisconnectsId(); - m_waitingConnectionsId = poolStatType->getWaitingConnectionsId(); - m_totalWaitingConnsId = poolStatType->getTotalWaitingConnsId(); - m_totalWaitingConnTimeId = poolStatType->getTotalWaitingConnTimeId(); - m_curClientOpsId = poolStatType->getCurClientOpsId(); - m_clientOpsSuccessId = poolStatType->getClientOpsSucceededId(); - m_clientOpsSuccessTimeId = poolStatType->getClientOpsSucceededTimeId(); - m_clientOpsFailedId = poolStatType->getClientOpsFailedId(); - m_clientOpsTimeoutId = poolStatType->getClientOpsTimeoutId(); - m_receivedBytesId = poolStatType->getReceivedBytesId(); - m_messagesBeingReceivedId = poolStatType->getMessagesBeingReceivedId(); - m_processedDeltaMessagesId = poolStatType->getProcessedDeltaMessagesId(); - m_deltaMessageFailuresId = poolStatType->getDeltaMessageFailuresId(); - m_processedDeltaMessagesTimeId = - poolStatType->getProcessedDeltaMessagesTimeId(); - m_queryExecutionsId = poolStatType->getQueryExecutionId(); - m_queryExecutionTimeId = poolStatType->getQueryExecutionTimeId(); getStats()->setInt(m_locatorsId, 0); getStats()->setInt(m_serversId, 0); getStats()->setInt(m_subsServsId, 0); @@ -290,8 +193,6 @@ PoolStats::PoolStats(const char* poolName) { getStats()->setInt(m_processedDeltaMessagesTimeId, 0); getStats()->setInt(m_queryExecutionsId, 0); getStats()->setLong(m_queryExecutionTimeId, 0); - - StatisticsManager::getExistingInstance()->forceSample(); } PoolStats::~PoolStats() { http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/PoolStatistics.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PoolStatistics.hpp b/src/cppcache/src/PoolStatistics.hpp index c882cfc..ae16a9d 100644 --- a/src/cppcache/src/PoolStatistics.hpp +++ b/src/cppcache/src/PoolStatistics.hpp @@ -1,5 +1,4 @@ /* - * 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 @@ -20,27 +19,13 @@ #ifndef GEODE_POOLSTATISTICS_H_ #define GEODE_POOLSTATISTICS_H_ -/* - * 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 <string> #include <geode/geode_globals.hpp> #include <geode/statistics/Statistics.hpp> #include <geode/statistics/StatisticsFactory.hpp> -#include <statistics/StatisticsManager.hpp> -#include "util/concurrent/spinlock_mutex.hpp" + +#include "statistics/StatisticsManager.hpp" namespace apache { namespace geode { @@ -54,15 +39,12 @@ using util::concurrent::spinlock_mutex; class PoolStats { public: /** hold statistics for a pool.. */ - PoolStats(const char* poolName); + PoolStats(statistics::StatisticsFactory* factory, const std::string& poolName); /** disable stat collection for this item. */ virtual ~PoolStats(); - void close() { - getStats()->close(); - statistics::StatisticsManager::getExistingInstance()->forceSample(); - } + void close() { getStats()->close(); } void setLocators(int32_t curVal) { getStats()->setInt(m_locatorsId, curVal); } @@ -147,6 +129,11 @@ class PoolStats { inline apache::geode::statistics::Statistics* getStats() { return m_poolStats; } + inline int32_t getTotalWaitingConnTimeId() { + return m_totalWaitingConnTimeId; + } + + inline int32_t getQueryExecutionTimeId() { return m_queryExecutionTimeId; } private: // volatile apache::geode::statistics::Statistics* m_poolStats; @@ -179,92 +166,9 @@ class PoolStats { int32_t m_processedDeltaMessagesTimeId; int32_t m_queryExecutionsId; int32_t m_queryExecutionTimeId; -}; - -class PoolStatType { - private: - static PoolStatType* single; - static spinlock_mutex m_singletonLock; - static spinlock_mutex m_statTypeLock; - - public: - static PoolStatType* getInstance(); - - statistics::StatisticsType* getStatType(); - - static void clean(); - private: - PoolStatType(); - statistics::StatisticDescriptor* m_stats[27]; - - int32_t m_locatorsId; - int32_t m_serversId; - int32_t m_subsServsId; - int32_t m_locReqsId; - int32_t m_locRespsId; - int32_t m_poolConnsId; - int32_t m_connectsId; - int32_t m_disconnectsId; - int32_t m_minPoolConnectsId; - int32_t m_loadCondConnectsId; - int32_t m_idleDisconnectsId; - int32_t m_loadCondDisconnectsId; - int32_t m_waitingConnectionsId; - int32_t m_totalWaitingConnsId; - int32_t m_totalWaitingConnTimeId; - int32_t m_curClientOpsId; - int32_t m_clientOpsSuccessId; - int32_t m_clientOpsSuccessTimeId; - int32_t m_clientOpsFailedId; - int32_t m_clientOpsTimeoutId; - int32_t m_receivedBytesId; - int32_t m_messagesBeingReceivedId; - int32_t m_processedDeltaMessagesId; - int32_t m_deltaMessageFailuresId; - int32_t m_processedDeltaMessagesTimeId; - int32_t m_queryExecutionsId; - int32_t m_queryExecutionTimeId; - - public: - int32_t getLocatorsId() { return m_locatorsId; } - - int32_t getServersId() { return m_serversId; } - - int32_t getSubscriptionServersId() { return m_subsServsId; } - - int32_t getLocatorRequestsId() { return m_locReqsId; } - - int32_t getLocatorResposesId() { return m_locRespsId; } - - int32_t getPoolConnectionsId() { return m_poolConnsId; } - - int32_t getConnectsId() { return m_connectsId; } - - int32_t getDisconnectsId() { return m_disconnectsId; } - - int32_t getMinPoolSizeConnectsId() { return m_minPoolConnectsId; } - - int32_t getLoadCondConnectsId() { return m_loadCondConnectsId; } - int32_t getIdleDisconnectsId() { return m_idleDisconnectsId; } - int32_t getLoadCondDisconnectsId() { return m_loadCondDisconnectsId; } - int32_t getWaitingConnectionsId() { return m_waitingConnectionsId; } - int32_t getTotalWaitingConnsId() { return m_totalWaitingConnsId; } - int32_t getTotalWaitingConnTimeId() { return m_totalWaitingConnTimeId; } - int32_t getCurClientOpsId() { return m_curClientOpsId; } - int32_t getClientOpsSucceededId() { return m_clientOpsSuccessId; } - int32_t getClientOpsSucceededTimeId() { return m_clientOpsSuccessTimeId; } - int32_t getClientOpsFailedId() { return m_clientOpsFailedId; } - int32_t getClientOpsTimeoutId() { return m_clientOpsTimeoutId; } - int32_t getReceivedBytesId() { return m_receivedBytesId; } - int32_t getMessagesBeingReceivedId() { return m_messagesBeingReceivedId; } - int32_t getProcessedDeltaMessagesId() { return m_processedDeltaMessagesId; } - int32_t getDeltaMessageFailuresId() { return m_deltaMessageFailuresId; } - int32_t getProcessedDeltaMessagesTimeId() { - return m_processedDeltaMessagesTimeId; - } - int32_t getQueryExecutionId() { return m_queryExecutionsId; } - int32_t getQueryExecutionTimeId() { return m_queryExecutionTimeId; } + static constexpr const char* STATS_NAME = "PoolStatistics"; + static constexpr const char* STATS_DESC = "Statistics for this pool"; }; } // namespace client } // namespace geode http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/PoolXmlCreation.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PoolXmlCreation.cpp b/src/cppcache/src/PoolXmlCreation.cpp index ecb42d6..45216c0 100644 --- a/src/cppcache/src/PoolXmlCreation.cpp +++ b/src/cppcache/src/PoolXmlCreation.cpp @@ -15,6 +15,9 @@ * limitations under the License. */ +#include <geode/Cache.hpp> +#include <geode/PoolManager.hpp> + #include "PoolXmlCreation.hpp" using namespace apache::geode::client; @@ -33,7 +36,7 @@ void PoolXmlCreation::addServer(const char * host, const char * port) } */ -PoolPtr PoolXmlCreation::create() { +PoolPtr PoolXmlCreation::create(Cache& cache) { return poolFactory->create(poolName.c_str()); } http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/PoolXmlCreation.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PoolXmlCreation.hpp b/src/cppcache/src/PoolXmlCreation.hpp index c6a3446..d3cb455 100644 --- a/src/cppcache/src/PoolXmlCreation.hpp +++ b/src/cppcache/src/PoolXmlCreation.hpp @@ -82,7 +82,7 @@ class CPPCACHE_EXPORT PoolXmlCreation { * @throws UnknownException otherwise * */ - PoolPtr create(); + PoolPtr create(Cache &cache); }; } // namespace client } // namespace geode http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/PreservedDataExpiryHandler.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PreservedDataExpiryHandler.cpp b/src/cppcache/src/PreservedDataExpiryHandler.cpp index 550edf6..5126020 100644 --- a/src/cppcache/src/PreservedDataExpiryHandler.cpp +++ b/src/cppcache/src/PreservedDataExpiryHandler.cpp @@ -33,14 +33,16 @@ using namespace apache::geode::client; PreservedDataExpiryHandler::PreservedDataExpiryHandler( - PdxSerializablePtr pdxObjectPtr, uint32_t duration) + const std::shared_ptr<PdxTypeRegistry>& pdxTypeRegistry, + const PdxSerializablePtr& pdxObjectPtr, uint32_t duration) : // UNUSED m_duration(duration), - m_pdxObjectPtr(pdxObjectPtr) {} + m_pdxObjectPtr(pdxObjectPtr), + m_pdxTypeRegistry(pdxTypeRegistry) {} int PreservedDataExpiryHandler::handle_timeout( const ACE_Time_Value& current_time, const void* arg) { - WriteGuard guard(PdxTypeRegistry::getPreservedDataLock()); - auto map = PdxTypeRegistry::getPreserveDataMap(); + WriteGuard guard(m_pdxTypeRegistry->getPreservedDataLock()); + auto map = m_pdxTypeRegistry->getPreserveDataMap(); LOGDEBUG( "Entered PreservedDataExpiryHandler " "PdxTypeRegistry::getPreserveDataMap().size() = %d", http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/PreservedDataExpiryHandler.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/PreservedDataExpiryHandler.hpp b/src/cppcache/src/PreservedDataExpiryHandler.hpp index ce85a87..e8aafc9 100644 --- a/src/cppcache/src/PreservedDataExpiryHandler.hpp +++ b/src/cppcache/src/PreservedDataExpiryHandler.hpp @@ -53,7 +53,8 @@ class CPPCACHE_EXPORT PreservedDataExpiryHandler : public ACE_Event_Handler { /** * Constructor */ - PreservedDataExpiryHandler(PdxSerializablePtr pdxObjectPtr, + PreservedDataExpiryHandler(const std::shared_ptr<PdxTypeRegistry>& pdxTypeRegistry, + const PdxSerializablePtr& pdxObjectPtr, uint32_t duration); /** This task object will be registered with the Timer Queue. @@ -69,6 +70,7 @@ class CPPCACHE_EXPORT PreservedDataExpiryHandler : public ACE_Event_Handler { // Duration after which the task should be reset in case of // modification. // UNUSED uint32_t m_duration; + std::shared_ptr<PdxTypeRegistry> m_pdxTypeRegistry; PdxSerializablePtr m_pdxObjectPtr; }; } // namespace client http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ProxyCache.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/ProxyCache.cpp b/src/cppcache/src/ProxyCache.cpp index 978919c..2d03a8b 100644 --- a/src/cppcache/src/ProxyCache.cpp +++ b/src/cppcache/src/ProxyCache.cpp @@ -69,7 +69,8 @@ void ProxyCache::close() { m_userAttributes->unSetCredentials(); // send message to server PoolPtr userAttachedPool = m_userAttributes->getPool(); - PoolPtr pool = PoolManager::find(userAttachedPool->getName()); + PoolPtr pool = m_cacheImpl->getCache()->getPoolManager().find( + userAttachedPool->getName()); if (pool != nullptr && pool.get() == userAttachedPool.get()) { auto poolDM = std::static_pointer_cast<ThinClientPoolDM>(pool); if (!poolDM->isDestroyed()) { @@ -86,15 +87,15 @@ RegionPtr ProxyCache::getRegion(const char* path) { if (!m_isProxyCacheClosed) { RegionPtr result; - CachePtr realCache = CacheFactory::getAnyInstance(); - if (realCache != nullptr && !realCache->isClosed()) { - CacheRegionHelper::getCacheImpl(realCache.get())->getRegion(path, result); + if (m_cacheImpl != nullptr && !m_cacheImpl->isClosed()) { + m_cacheImpl->getRegion(path, result); } if (result != nullptr) { PoolPtr userAttachedPool = m_userAttributes->getPool(); - PoolPtr pool = PoolManager::find(result->getAttributes()->getPoolName()); + PoolPtr pool = m_cacheImpl->getCache()->getPoolManager().find( + result->getAttributes()->getPoolName()); if (pool != nullptr && pool.get() == userAttachedPool.get() && !pool->isDestroyed()) { return std::make_shared<ProxyRegion>(shared_from_this(), result); @@ -134,13 +135,12 @@ void ProxyCache::rootRegions(VectorOfRegion& regions) { if (!m_isProxyCacheClosed) { RegionPtr result; - CachePtr realCache = CacheFactory::getAnyInstance(); - if (realCache != nullptr && !realCache->isClosed()) { + if (m_cacheImpl != nullptr && !m_cacheImpl->isClosed()) { VectorOfRegion tmp; // this can cause issue when pool attached with region in multiuserSecure // mode - realCache->rootRegions(tmp); + m_cacheImpl->rootRegions(tmp); if (tmp.size() > 0) { for (int32_t i = 0; i < tmp.size(); i++) { @@ -157,15 +157,22 @@ void ProxyCache::rootRegions(VectorOfRegion& regions) { } } -ProxyCache::ProxyCache(PropertiesPtr credentials, PoolPtr pool) { - m_remoteQueryService = nullptr; - m_isProxyCacheClosed = false; - m_userAttributes = std::make_shared<UserAttributes>(credentials, pool, this); -} +ProxyCache::ProxyCache(PropertiesPtr credentials, PoolPtr pool, + CacheImpl* cacheImpl) + : m_remoteQueryService(nullptr), + m_isProxyCacheClosed(false), + m_userAttributes( + std::make_shared<UserAttributes>(credentials, pool, this)), + m_cacheImpl(cacheImpl) {} ProxyCache::~ProxyCache() {} PdxInstanceFactoryPtr ProxyCache::createPdxInstanceFactory( const char* className) { - return std::make_shared<PdxInstanceFactoryImpl>(className); + return std::make_shared<PdxInstanceFactoryImpl>( + className, &(m_cacheImpl->getCachePerfStats()), + m_cacheImpl->getPdxTypeRegistry(), m_cacheImpl->getCache(), + m_cacheImpl->getDistributedSystem() + .getSystemProperties() + .getEnableTimeStatistics()); } http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ProxyCache.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/ProxyCache.hpp b/src/cppcache/src/ProxyCache.hpp index 23d085c..acbc295 100644 --- a/src/cppcache/src/ProxyCache.hpp +++ b/src/cppcache/src/ProxyCache.hpp @@ -86,28 +86,28 @@ class CPPCACHE_EXPORT ProxyCache virtual RegionPtr getRegion(const char* path); /** - * Gets the QueryService from which a new Query can be obtained. - * - * @returns A smart pointer to the QueryService. - */ + * Gets the QueryService from which a new Query can be obtained. + * + * @returns A smart pointer to the QueryService. + */ virtual QueryServicePtr getQueryService(); /** - * Returns a set of root regions in the cache. This set is a snapshot and - * is not backed by the Cache. The vector passed in is cleared and the - * regions are added to it. - * - * @param regions the returned set of - * regions - */ + * Returns a set of root regions in the cache. This set is a snapshot and + * is not backed by the Cache. The vector passed in is cleared and the + * regions are added to it. + * + * @param regions the returned set of + * regions + */ virtual void rootRegions(VectorOfRegion& regions); /** - * @brief destructor - */ + * @brief destructor + */ virtual ~ProxyCache(); - ProxyCache(PropertiesPtr credentials, PoolPtr pool); + ProxyCache(PropertiesPtr credentials, PoolPtr pool, CacheImpl* cacheImpl); /** * Returns a factory that can create a {@link PdxInstance}. @@ -126,6 +126,7 @@ class CPPCACHE_EXPORT ProxyCache UserAttributesPtr m_userAttributes; bool m_isProxyCacheClosed; QueryServicePtr m_remoteQueryService; + CacheImpl* m_cacheImpl; friend class Pool; friend class ProxyRegion; friend class ProxyRemoteQueryService; @@ -134,6 +135,7 @@ class CPPCACHE_EXPORT ProxyCache friend class FunctionServiceImpl; friend class FunctionService; friend class GuardUserAttribures; + friend class CacheRegionHelper; }; } // namespace client } // namespace geode http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ProxyRegion.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/ProxyRegion.hpp b/src/cppcache/src/ProxyRegion.hpp index d0b77bc..d4d5940 100644 --- a/src/cppcache/src/ProxyRegion.hpp +++ b/src/cppcache/src/ProxyRegion.hpp @@ -1495,21 +1495,22 @@ class CPPCACHE_EXPORT ProxyRegion : public Region { virtual const PoolPtr& getPool() { return m_realRegion->getPool(); } - ProxyRegion(const ProxyCachePtr& proxyCache, const RegionPtr& realRegion) { + ProxyRegion(const ProxyCachePtr& proxyCache, const RegionPtr& realRegion) + : Region(realRegion->getCache()) { m_proxyCache = proxyCache; m_realRegion = realRegion; } virtual ~ProxyRegion() {} + ProxyRegion(const ProxyRegion&) = delete; + ProxyRegion& operator=(const ProxyRegion&) = delete; + private: void unSupportedOperation(const char* operationName) const; ProxyCachePtr m_proxyCache; RegionPtr m_realRegion; - // Disallow copy constructor and assignment operator. - ProxyRegion(const ProxyRegion&); - ProxyRegion& operator=(const ProxyRegion&); friend class FunctionService; FRIEND_STD_SHARED_PTR(ProxyRegion) http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/ProxyRemoteQueryService.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/ProxyRemoteQueryService.cpp b/src/cppcache/src/ProxyRemoteQueryService.cpp index da66e0b..25aec8a 100644 --- a/src/cppcache/src/ProxyRemoteQueryService.cpp +++ b/src/cppcache/src/ProxyRemoteQueryService.cpp @@ -25,7 +25,8 @@ ProxyRemoteQueryService::ProxyRemoteQueryService(ProxyCachePtr cptr) QueryPtr ProxyRemoteQueryService::newQuery(const char* querystring) { if (!m_proxyCache->isClosed()) { auto userAttachedPool = m_proxyCache->m_userAttributes->getPool(); - auto pool = PoolManager::find(userAttachedPool->getName()); + auto pool = m_proxyCache->m_cacheImpl->getCache()->getPoolManager().find( + userAttachedPool->getName()); if (pool != nullptr && pool.get() == userAttachedPool.get() && !pool->isDestroyed()) { GuardUserAttribures gua(m_proxyCache); @@ -53,7 +54,8 @@ CqQueryPtr ProxyRemoteQueryService::newCq(const char* querystr, bool isDurable) { if (!m_proxyCache->isClosed()) { auto userAttachedPool = m_proxyCache->m_userAttributes->getPool(); - auto pool = PoolManager::find(userAttachedPool->getName()); + auto pool = m_proxyCache->m_cacheImpl->getCache()->getPoolManager().find( + userAttachedPool->getName()); if (pool != nullptr && pool.get() == userAttachedPool.get() && !pool->isDestroyed()) { GuardUserAttribures gua(m_proxyCache); @@ -81,7 +83,8 @@ CqQueryPtr ProxyRemoteQueryService::newCq(const char* name, bool isDurable) { if (!m_proxyCache->isClosed()) { auto userAttachedPool = m_proxyCache->m_userAttributes->getPool(); - auto pool = PoolManager::find(userAttachedPool->getName()); + auto pool = m_proxyCache->m_cacheImpl->getCache()->getPoolManager().find( + userAttachedPool->getName()); if (pool != nullptr && pool.get() == userAttachedPool.get() && !pool->isDestroyed()) { GuardUserAttribures gua(m_proxyCache); @@ -114,12 +117,12 @@ void ProxyRemoteQueryService::closeCqs(bool keepAlive) { cqImpl->close(false); } } catch (QueryException& qe) { - Log::fine(("Failed to close the CQ, CqName : " + cqName + " Error : " + - qe.getMessage()) + Log::fine(("Failed to close the CQ, CqName : " + cqName + + " Error : " + qe.getMessage()) .c_str()); } catch (CqClosedException& cce) { - Log::fine(("Failed to close the CQ, CqName : " + cqName + " Error : " + - cce.getMessage()) + Log::fine(("Failed to close the CQ, CqName : " + cqName + + " Error : " + cce.getMessage()) .c_str()); } } @@ -133,7 +136,8 @@ void ProxyRemoteQueryService::getCqs(query_container_type& vec) { CqQueryPtr ProxyRemoteQueryService::getCq(const char* name) { if (!m_proxyCache->isClosed()) { auto userAttachedPool = m_proxyCache->m_userAttributes->getPool(); - auto pool = PoolManager::find(userAttachedPool->getName()); + auto pool = m_proxyCache->m_cacheImpl->getCache()->getPoolManager().find( + userAttachedPool->getName()); if (pool != nullptr && pool.get() == userAttachedPool.get() && !pool->isDestroyed()) { GuardUserAttribures gua(m_proxyCache); @@ -155,12 +159,12 @@ void ProxyRemoteQueryService::executeCqs() { try { q->execute(); } catch (QueryException& qe) { - Log::fine(("Failed to excecue the CQ, CqName : " + cqName + " Error : " + - qe.getMessage()) + Log::fine(("Failed to excecue the CQ, CqName : " + cqName + + " Error : " + qe.getMessage()) .c_str()); } catch (CqClosedException& cce) { - Log::fine(("Failed to excecue the CQ, CqName : " + cqName + " Error : " + - cce.getMessage()) + Log::fine(("Failed to excecue the CQ, CqName : " + cqName + + " Error : " + cce.getMessage()) .c_str()); } } @@ -174,12 +178,12 @@ void ProxyRemoteQueryService::stopCqs() { try { q->stop(); } catch (QueryException& qe) { - Log::fine(("Failed to stop the CQ, CqName : " + cqName + " Error : " + - qe.getMessage()) + Log::fine(("Failed to stop the CQ, CqName : " + cqName + + " Error : " + qe.getMessage()) .c_str()); } catch (CqClosedException& cce) { - Log::fine(("Failed to stop the CQ, CqName : " + cqName + " Error : " + - cce.getMessage()) + Log::fine(("Failed to stop the CQ, CqName : " + cqName + + " Error : " + cce.getMessage()) .c_str()); } } http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/Region.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/Region.cpp b/src/cppcache/src/Region.cpp index eab6760..fa1ce3e 100644 --- a/src/cppcache/src/Region.cpp +++ b/src/cppcache/src/Region.cpp @@ -20,7 +20,7 @@ namespace apache { namespace geode { namespace client { -Region::Region() {} +Region::Region(const CachePtr& cache) : m_cache(cache) {} Region::~Region() {} } // namespace client } // namespace geode http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RegionCommit.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RegionCommit.cpp b/src/cppcache/src/RegionCommit.cpp index 62e26c8..3bef90c 100644 --- a/src/cppcache/src/RegionCommit.cpp +++ b/src/cppcache/src/RegionCommit.cpp @@ -38,9 +38,11 @@ void RegionCommit::fromData(DataInput& input) { input.readBoolean(&largeModCount); DSMemberForVersionStampPtr dsMember; input.readObject(dsMember); - uint16_t memId = CacheImpl::getMemberListForVersionStamp()->add(dsMember); + + auto memId = m_memberListForVersionStamp.add(dsMember); for (int i = 0; i < size; i++) { - auto entryOp = std::make_shared<FarSideEntryOp>(this); + auto entryOp = + std::make_shared<FarSideEntryOp>(this, m_memberListForVersionStamp); entryOp->fromData(input, largeModCount, memId); m_farSideEntryOps.push_back(entryOp); } http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RegionCommit.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RegionCommit.hpp b/src/cppcache/src/RegionCommit.hpp index 9458bee..0d24dfb 100644 --- a/src/cppcache/src/RegionCommit.hpp +++ b/src/cppcache/src/RegionCommit.hpp @@ -38,10 +38,12 @@ namespace geode { namespace client { _GF_PTR_DEF_(RegionCommit, RegionCommitPtr); +_GF_PTR_DEF_(FarSideEntryOp, FarSideEntryOpPtr); class RegionCommit { public: - RegionCommit(){}; + RegionCommit(MemberListForVersionStamp& memberListForVersionStamp): m_memberListForVersionStamp(memberListForVersionStamp) + {}; virtual ~RegionCommit(){}; void fromData(DataInput& input); @@ -55,6 +57,7 @@ class RegionCommit { CacheableStringPtr m_regionPath; CacheableStringPtr m_parentRegionPath; std::vector< std::shared_ptr<FarSideEntryOp> > m_farSideEntryOps; + MemberListForVersionStamp& m_memberListForVersionStamp; }; } // namespace client } // namespace geode http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RegionExpiryHandler.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RegionExpiryHandler.cpp b/src/cppcache/src/RegionExpiryHandler.cpp index 66e74c5..ba97f16 100644 --- a/src/cppcache/src/RegionExpiryHandler.cpp +++ b/src/cppcache/src/RegionExpiryHandler.cpp @@ -62,14 +62,17 @@ int RegionExpiryHandler::handle_timeout(const ACE_Time_Value& current_time, // (lastAccessTime + entryExpiryDuration - curr_time) in seconds LOGDEBUG("Resetting expiry task for region [%s] after %d sec", m_regionPtr->getFullPath(), -sec); - CacheImpl::expiryTaskManager->resetTask(m_expiryTaskId, -sec); + m_regionPtr->getCacheImpl()->getExpiryTaskManager().resetTask( + m_expiryTaskId, -sec); return 0; } + LOGDEBUG("Removing expiry task for region [%s]", + m_regionPtr->getFullPath()); + m_regionPtr->getCacheImpl()->getExpiryTaskManager().resetTask( + m_expiryTaskId, 0); } catch (...) { // Ignore whatever exception comes } - LOGDEBUG("Removing expiry task for region [%s]", m_regionPtr->getFullPath()); - CacheImpl::expiryTaskManager->resetTask(m_expiryTaskId, 0); // we now delete the handler in GF_Timer_Heap_ImmediateReset_T // and always return success. return 0; http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RegionFactory.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RegionFactory.cpp b/src/cppcache/src/RegionFactory.cpp index a25b7e3..6d2b41a 100644 --- a/src/cppcache/src/RegionFactory.cpp +++ b/src/cppcache/src/RegionFactory.cpp @@ -35,10 +35,11 @@ namespace apache { namespace geode { namespace client { -RegionFactory::RegionFactory(RegionShortcut preDefinedRegion) { - m_preDefinedRegion = preDefinedRegion; - m_attributeFactory = std::make_shared<AttributesFactory>(); - ; +RegionFactory::RegionFactory(RegionShortcut preDefinedRegion, + CacheImpl* cacheImpl) + : m_preDefinedRegion(preDefinedRegion), + m_attributeFactory(std::make_shared<AttributesFactory>()), + m_cacheImpl(cacheImpl) { setRegionShortcut(); } @@ -47,36 +48,38 @@ RegionFactory::~RegionFactory() {} RegionPtr RegionFactory::create(const char* name) { RegionPtr retRegionPtr = nullptr; RegionAttributesPtr regAttr = m_attributeFactory->createRegionAttributes(); - - // assuming pool name is not DEFAULT_POOL_NAME - if (regAttr->getPoolName() != nullptr && strlen(regAttr->getPoolName()) > 0) { - // poolname is set - CachePtr cache = CacheFactory::getAnyInstance(); - CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.get()); - cacheImpl->createRegion(name, regAttr, retRegionPtr); - } else { - // need to look default Pool - ACE_Guard<ACE_Recursive_Thread_Mutex> connectGuard(*g_disconnectLock); - // if local region no need to create default pool - if (m_preDefinedRegion != LOCAL) { - PoolPtr pool = CacheFactory::createOrGetDefaultPool(); - if (pool == nullptr) { - throw IllegalStateException("Pool is not defined create region."); - } - m_attributeFactory->setPoolName(pool->getName()); + if (m_preDefinedRegion != LOCAL && (regAttr->getPoolName() == nullptr || + strlen(regAttr->getPoolName()) == 0)) { + auto pool = m_cacheImpl->getPoolManager().getDefaultPool(); + if (!pool) { + throw IllegalStateException("No pool for non-local region."); } - + m_attributeFactory->setPoolName(pool->getName()); regAttr = m_attributeFactory->createRegionAttributes(); - CachePtr cache = CacheFactory::getAnyInstance(); - CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache.get()); - cacheImpl->createRegion(name, regAttr, retRegionPtr); } + m_cacheImpl->createRegion(name, regAttr, retRegionPtr); return retRegionPtr; } void RegionFactory::setRegionShortcut() { - CacheImpl::setRegionShortcut(m_attributeFactory, m_preDefinedRegion); + switch (m_preDefinedRegion) { + case PROXY: { + m_attributeFactory->setCachingEnabled(false); + } break; + case CACHING_PROXY: { + m_attributeFactory->setCachingEnabled(true); + } break; + case CACHING_PROXY_ENTRY_LRU: { + m_attributeFactory->setCachingEnabled(true); + m_attributeFactory->setLruEntriesLimit(DEFAULT_LRU_MAXIMUM_ENTRIES); + } break; + case LOCAL: { + } break; + case LOCAL_ENTRY_LRU: { + m_attributeFactory->setLruEntriesLimit(DEFAULT_LRU_MAXIMUM_ENTRIES); + } break; + } } RegionFactoryPtr RegionFactory::setCacheLoader( http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RegionInternal.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RegionInternal.cpp b/src/cppcache/src/RegionInternal.cpp index 0dc47cb..860acfe 100644 --- a/src/cppcache/src/RegionInternal.cpp +++ b/src/cppcache/src/RegionInternal.cpp @@ -37,8 +37,9 @@ const CacheEventFlags CacheEventFlags::CACHE_CLOSE( const CacheEventFlags CacheEventFlags::NOCACHEWRITER( CacheEventFlags::GF_NOCACHEWRITER); -RegionInternal::RegionInternal(const RegionAttributesPtr& attributes) - : m_regionAttributes(attributes) {} +RegionInternal::RegionInternal(const CachePtr& cache, + const RegionAttributesPtr& attributes) + : Region(cache), m_regionAttributes(attributes) {} RegionInternal::~RegionInternal() {} http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RegionInternal.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RegionInternal.hpp b/src/cppcache/src/RegionInternal.hpp index 1b8c639..4b30bca 100644 --- a/src/cppcache/src/RegionInternal.hpp +++ b/src/cppcache/src/RegionInternal.hpp @@ -82,26 +82,40 @@ class CacheEventFlags { return (m_flags == flags.m_flags); } - inline bool isNormal() const { return (m_flags & GF_NORMAL); } + inline bool isNormal() const { + return (m_flags & GF_NORMAL) > 0 ? true : false; + } - inline bool isLocal() const { return (m_flags & GF_LOCAL); } + inline bool isLocal() const { + return (m_flags & GF_LOCAL) > 0 ? true : false; + } - inline bool isNotification() const { return (m_flags & GF_NOTIFICATION); } + inline bool isNotification() const { + return (m_flags & GF_NOTIFICATION) > 0 ? true : false; + } inline bool isNotificationUpdate() const { - return (m_flags & GF_NOTIFICATION_UPDATE); + return (m_flags & GF_NOTIFICATION_UPDATE) > 0 ? true : false; } - inline bool isEviction() const { return (m_flags & GF_EVICTION); } + inline bool isEviction() const { + return (m_flags & GF_EVICTION) > 0 ? true : false; + } - inline bool isExpiration() const { return (m_flags & GF_EXPIRATION); } + inline bool isExpiration() const { + return (m_flags & GF_EXPIRATION) > 0 ? true : false; + } - inline bool isCacheClose() const { return (m_flags & GF_CACHE_CLOSE); } + inline bool isCacheClose() const { + return (m_flags & GF_CACHE_CLOSE) > 0 ? true : false; + } - inline bool isNoCacheWriter() const { return (m_flags & GF_NOCACHEWRITER); } + inline bool isNoCacheWriter() const { + return (m_flags & GF_NOCACHEWRITER) > 0 ? true : false; + } inline bool isEvictOrExpire() const { - return (m_flags & (GF_EVICTION | GF_EXPIRATION)); + return (m_flags & (GF_EVICTION | GF_EXPIRATION)) > 0 ? true : false; } // special optimized method for CacheWriter invocation condition @@ -254,7 +268,7 @@ class RegionInternal : public Region { /** * @brief constructor */ - RegionInternal(const RegionAttributesPtr& attributes); + RegionInternal(const CachePtr& cache, const RegionAttributesPtr& attributes); void setLruEntriesLimit(uint32_t limit); void setRegionTimeToLiveExpirationAction(ExpirationAction::Action action); @@ -286,10 +300,8 @@ class RegionInternal : public Region { return m_regionAttributes->getRegionExpiryEnabled(); } - private: - // Disallow copy constructor and assignment operator. - RegionInternal(const RegionInternal&); - RegionInternal& operator=(const RegionInternal&); + RegionInternal(const RegionInternal&) = delete; + RegionInternal& operator=(const RegionInternal&) = delete; }; typedef std::shared_ptr<RegionInternal> RegionInternalPtr; http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RegionStats.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RegionStats.cpp b/src/cppcache/src/RegionStats.cpp index e8f8004..3c6192c 100644 --- a/src/cppcache/src/RegionStats.cpp +++ b/src/cppcache/src/RegionStats.cpp @@ -15,22 +15,13 @@ * limitations under the License. */ -#include <geode/geode_globals.hpp> - -#include "RegionStats.hpp" -//#include "StatisticsFactory.hpp" - #include <ace/Thread_Mutex.h> #include <ace/Singleton.h> -#include <mutex> - -#include "util/concurrent/spinlock_mutex.hpp" - -const char* statsName = "RegionStatistics"; -const char* statsDesc = "Statistics for this region"; +#include <geode/geode_globals.hpp> +#include <util/concurrent/spinlock_mutex.hpp> -//////////////////////////////////////////////////////////////////////////////// +#include "RegionStats.hpp" namespace apache { namespace geode { @@ -39,124 +30,111 @@ namespace client { using statistics::StatisticsFactory; using util::concurrent::spinlock_mutex; -//////////////////////////////////////////////////////////////////////////////// - -RegionStatType* RegionStatType::single = nullptr; -spinlock_mutex RegionStatType::m_singletonLock; -spinlock_mutex RegionStatType::m_statTypeLock; +constexpr const char* RegionStats::STATS_NAME; +constexpr const char* RegionStats::STATS_DESC; -void RegionStatType::clean() { - std::lock_guard<spinlock_mutex> guard(m_singletonLock); - if (single) { - delete single; - single = nullptr; - } -} +RegionStats::RegionStats(StatisticsFactory* factory, + const std::string& regionName) { + auto statsType = factory->findType(STATS_NAME); -StatisticsType* RegionStatType::getStatType() { - const bool largerIsBetter = true; - std::lock_guard<spinlock_mutex> guard(m_statTypeLock); - StatisticsFactory* factory = StatisticsFactory::getExistingInstance(); - GF_D_ASSERT(!!factory); - - StatisticsType* statsType = factory->findType("RegionStatistics"); - - if (statsType == nullptr) { - m_stats[0] = factory->createIntCounter( + if (!statsType) { + const bool largerIsBetter = true; + auto stats = new StatisticDescriptor*[25]; + stats[0] = factory->createIntCounter( "creates", "The total number of cache creates for this region", "entries", largerIsBetter); - m_stats[1] = factory->createIntCounter( + stats[1] = factory->createIntCounter( "puts", "The total number of cache puts for this region", "entries", largerIsBetter); - m_stats[2] = factory->createIntCounter( + stats[2] = factory->createIntCounter( "gets", "The total number of cache gets for this region", "entries", largerIsBetter); - m_stats[3] = factory->createIntCounter( + stats[3] = factory->createIntCounter( "hits", "The total number of cache hits for this region", "entries", largerIsBetter); - m_stats[4] = factory->createIntCounter( + stats[4] = factory->createIntCounter( "misses", "The total number of cache misses for this region", "entries", !largerIsBetter); - m_stats[5] = factory->createIntGauge( + stats[5] = factory->createIntGauge( "entries", "The current number of cache entries for this region", "entries", largerIsBetter); - m_stats[6] = factory->createIntCounter( + stats[6] = factory->createIntCounter( "destroys", "The total number of cache destroys for this region", "entries", largerIsBetter); - m_stats[7] = + stats[7] = factory->createIntCounter("overflows", "The total number of cache overflows for " "this region to persistence backup", "entries", largerIsBetter); - m_stats[8] = + stats[8] = factory->createIntCounter("retrieves", "The total number of cache entries fetched " "from persistence backup into the cache", "entries", largerIsBetter); - m_stats[9] = + stats[9] = factory->createIntCounter("metaDataRefreshCount", "The total number of times matadata is " "refreshed due to hoping observed", "entries", !largerIsBetter); - m_stats[10] = factory->createIntCounter( + stats[10] = factory->createIntCounter( "getAll", "The total number of cache getAll for this region", "entries", largerIsBetter); - m_stats[11] = factory->createIntCounter( + stats[11] = factory->createIntCounter( "putAll", "The total number of cache putAll for this region", "entries", largerIsBetter); - m_stats[12] = factory->createLongCounter( + stats[12] = factory->createLongCounter( "getTime", "Total time spent doing get operations for this region", "Nanoseconds", !largerIsBetter); - m_stats[13] = factory->createLongCounter( + stats[13] = factory->createLongCounter( "putTime", "Total time spent doing puts operations for this region", "Nanoseconds", !largerIsBetter); - m_stats[14] = factory->createLongCounter( + stats[14] = factory->createLongCounter( "putAllTime", "Total time spent doing putAlls operations for this region", "Nanoseconds", !largerIsBetter); - m_stats[15] = factory->createLongCounter( + stats[15] = factory->createLongCounter( "getAllTime", "Total time spent doing the getAlls operations for this region", "Nanoseconds", !largerIsBetter); - m_stats[16] = factory->createIntCounter( + stats[16] = factory->createIntCounter( "cacheLoaderCallsCompleted", "Total number of times a load has completed for this region", "entries", largerIsBetter); - m_stats[17] = factory->createLongCounter( + stats[17] = factory->createLongCounter( "cacheLoaderCallTIme", "Total time spent invoking the loaders for this region", "Nanoseconds", !largerIsBetter); - m_stats[18] = + stats[18] = factory->createIntCounter("cacheWriterCallsCompleted", "Total number of times a cache writer call " "has completed for this region", "entries", largerIsBetter); - m_stats[19] = factory->createLongCounter( + stats[19] = factory->createLongCounter( "cacheWriterCallTime", "Total time spent doing cache writer calls", "Nanoseconds", !largerIsBetter); - m_stats[20] = + stats[20] = factory->createIntCounter("cacheListenerCallsCompleted", "Total number of times a cache listener call " "has completed for this region", "entries", largerIsBetter); - m_stats[21] = factory->createLongCounter( + stats[21] = factory->createLongCounter( "cacheListenerCallTime", "Total time spent doing cache listener calls for this region", "Nanoseconds", !largerIsBetter); - m_stats[22] = + stats[22] = factory->createIntCounter("clears", "The total number of times a clear has been " "done on this cache for this region", "entries", !largerIsBetter); - m_stats[23] = factory->createIntCounter( + stats[23] = factory->createIntCounter( "removeAll", "The total number of cache removeAll for this region", "entries", largerIsBetter); - m_stats[24] = factory->createLongCounter( + stats[24] = factory->createLongCounter( "removeAllTime", "Total time spent doing removeAlls operations for this region", "Nanoseconds", !largerIsBetter); - statsType = factory->createType(statsName, statsDesc, m_stats, 25); + statsType = factory->createType(STATS_NAME, STATS_DESC, stats, 25); } m_destroysId = statsType->nameToId("destroys"); @@ -186,87 +164,8 @@ StatisticsType* RegionStatType::getStatType() { m_ListenerCallTimeId = statsType->nameToId("cacheListenerCallTime"); m_clearsId = statsType->nameToId("clears"); - return statsType; -} - -RegionStatType* RegionStatType::getInstance() { - std::lock_guard<spinlock_mutex> guard(m_singletonLock); - if (!single) { - single = new RegionStatType(); - } - return single; -} - -RegionStatType::RegionStatType() - : m_destroysId(0), - m_createsId(0), - m_putsId(0), - m_putTimeId(0), - m_putAllId(0), - m_putAllTimeId(0), - m_removeAllId(0), - m_removeAllTimeId(0), - m_getsId(0), - m_getTimeId(0), - m_getAllId(0), - m_getAllTimeId(0), - m_hitsId(0), - m_missesId(0), - m_entriesId(0), - m_overflowsId(0), - m_retrievesId(0), - m_metaDataRefreshId(0), - m_LoaderCallsCompletedId(0), - m_LoaderCallTimeId(0), - m_WriterCallsCompletedId(0), - m_WriterCallTimeId(0), - m_ListenerCallsCompletedId(0), - m_ListenerCallTimeId(0), - m_clearsId(0) {} - -//////////////////////////////////////////////////////////////////////////////// - -// typedef ACE_Singleton<RegionStatsInit, ACE_Thread_Mutex> TheRegionStatsInit; - -//////////////////////////////////////////////////////////////////////////////// - -RegionStats::RegionStats(const char* regionName) { - RegionStatType* regStatType = RegionStatType::getInstance(); - - StatisticsType* statsType = regStatType->getStatType(); - - GF_D_ASSERT(statsType != nullptr); - - StatisticsFactory* factory = StatisticsFactory::getExistingInstance(); - - m_regionStats = - factory->createAtomicStatistics(statsType, const_cast<char*>(regionName)); - - m_destroysId = regStatType->getDestroysId(); - m_createsId = regStatType->getCreatesId(); - m_putsId = regStatType->getPutsId(); - m_putTimeId = regStatType->getPutTimeId(); - m_getsId = regStatType->getGetsId(); - m_getTimeId = regStatType->getGetTimeId(); - m_getAllId = regStatType->getGetAllId(); - m_getAllTimeId = regStatType->getGetAllTimeId(); - m_putAllId = regStatType->getPutAllId(); - m_putAllTimeId = regStatType->getPutAllTimeId(); - m_removeAllId = regStatType->getRemoveAllId(); - m_removeAllTimeId = regStatType->getRemoveAllTimeId(); - m_hitsId = regStatType->getHitsId(); - m_missesId = regStatType->getMissesId(); - m_entriesId = regStatType->getEntriesId(); - m_overflowsId = regStatType->getOverflowsId(); - m_retrievesId = regStatType->getRetrievesId(); - m_metaDataRefreshId = regStatType->getMetaDataRefreshCount(); - m_LoaderCallsCompletedId = regStatType->getLoaderCallsCompletedId(); - m_LoaderCallTimeId = regStatType->getLoaderCallTimeId(); - m_WriterCallsCompletedId = regStatType->getWriterCallsCompletedId(); - m_WriterCallTimeId = regStatType->getWriterCallTimeId(); - m_ListenerCallsCompletedId = regStatType->getListenerCallsCompletedId(); - m_ListenerCallTimeId = regStatType->getListenerCallTimeId(); - m_clearsId = regStatType->getClearsId(); + m_regionStats = factory->createAtomicStatistics( + statsType, const_cast<char*>(regionName.c_str())); m_regionStats->setInt(m_destroysId, 0); m_regionStats->setInt(m_createsId, 0); http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RegionStats.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RegionStats.hpp b/src/cppcache/src/RegionStats.hpp index f37ca1b..0bedfde 100644 --- a/src/cppcache/src/RegionStats.hpp +++ b/src/cppcache/src/RegionStats.hpp @@ -20,10 +20,11 @@ #ifndef GEODE_REGIONSTATS_H_ #define GEODE_REGIONSTATS_H_ +#include <string> + #include <geode/geode_globals.hpp> #include <geode/statistics/Statistics.hpp> #include <geode/statistics/StatisticsFactory.hpp> -#include "util/concurrent/spinlock_mutex.hpp" namespace apache { namespace geode { @@ -32,12 +33,11 @@ namespace client { using statistics::StatisticDescriptor; using statistics::StatisticsType; using statistics::Statistics; -using util::concurrent::spinlock_mutex; class CPPCACHE_EXPORT RegionStats { public: /** hold statistics for a region.. */ - RegionStats(const char* regionName); + RegionStats(statistics::StatisticsFactory* factory, const std::string& regionName); /** disable stat collection for this item. */ virtual ~RegionStats(); @@ -88,56 +88,32 @@ class CPPCACHE_EXPORT RegionStats { inline void incClears() { m_regionStats->incInt(m_clearsId, 1); } + inline void updateGetTime() { m_regionStats->incInt(m_clearsId, 1); } + inline apache::geode::statistics::Statistics* getStat() { return m_regionStats; } - private: - apache::geode::statistics::Statistics* m_regionStats; + inline int32_t getGetTimeId() { return m_getTimeId; } - int32_t m_destroysId; - int32_t m_createsId; - int32_t m_putsId; - int32_t m_putTimeId; - int32_t m_putAllId; - int32_t m_putAllTimeId; - int32_t m_removeAllId; - int32_t m_removeAllTimeId; - int32_t m_getsId; - int32_t m_getTimeId; - int32_t m_getAllId; - int32_t m_getAllTimeId; - int32_t m_hitsId; - int32_t m_missesId; - int32_t m_entriesId; - int32_t m_overflowsId; - int32_t m_retrievesId; - int32_t m_metaDataRefreshId; - int32_t m_LoaderCallsCompletedId; - int32_t m_LoaderCallTimeId; - int32_t m_WriterCallsCompletedId; - int32_t m_WriterCallTimeId; - int32_t m_ListenerCallsCompletedId; - int32_t m_ListenerCallTimeId; - int32_t m_clearsId; -}; + inline int32_t getPutTimeId() { return m_putTimeId; } -class RegionStatType { - private: - static RegionStatType* single; - static spinlock_mutex m_singletonLock; - static spinlock_mutex m_statTypeLock; + inline int32_t getGetAllTimeId() { return m_getAllTimeId; } - public: - static RegionStatType* getInstance(); + inline int32_t getPutAllTimeId() { return m_putAllTimeId; } + + inline int32_t getRemoveAllTimeId() { return m_removeAllTimeId; } - statistics::StatisticsType* getStatType(); + inline int32_t getLoaderCallTimeId() { return m_LoaderCallTimeId; } - static void clean(); + inline int32_t getWriterCallTimeId() { return m_WriterCallTimeId; } + + inline int32_t getListenerCallTimeId() { return m_ListenerCallTimeId; } + + inline int32_t getClearsId() { return m_clearsId; } private: - RegionStatType(); - statistics::StatisticDescriptor* m_stats[25]; + apache::geode::statistics::Statistics* m_regionStats; int32_t m_destroysId; int32_t m_createsId; @@ -165,63 +141,10 @@ class RegionStatType { int32_t m_ListenerCallTimeId; int32_t m_clearsId; - public: - inline int32_t getDestroysId() { return m_destroysId; } - - inline int32_t getCreatesId() { return m_createsId; } - - inline int32_t getPutsId() { return m_putsId; } - - inline int32_t getPutTimeId() { return m_putTimeId; } - - inline int32_t getPutAllId() { return m_putAllId; } - - inline int32_t getPutAllTimeId() { return m_putAllTimeId; } - - inline int32_t getRemoveAllId() { return m_removeAllId; } - - inline int32_t getRemoveAllTimeId() { return m_removeAllTimeId; } - - inline int32_t getGetsId() { return m_getsId; } - - inline int32_t getGetTimeId() { return m_getTimeId; } - - inline int32_t getGetAllId() { return m_getAllId; } - - inline int32_t getGetAllTimeId() { return m_getAllTimeId; } - - inline int32_t getHitsId() { return m_hitsId; } - - inline int32_t getMissesId() { return m_missesId; } - - inline int32_t getEntriesId() { return m_entriesId; } - - inline int32_t getOverflowsId() { return m_overflowsId; } - - inline int32_t getRetrievesId() { return m_retrievesId; } - - inline int32_t getMetaDataRefreshCount() { return m_metaDataRefreshId; } - - inline int32_t getLoaderCallsCompletedId() { - return m_LoaderCallsCompletedId; - } - - inline int32_t getLoaderCallTimeId() { return m_LoaderCallTimeId; } - - inline int32_t getWriterCallsCompletedId() { - return m_WriterCallsCompletedId; - } - - inline int32_t getWriterCallTimeId() { return m_WriterCallTimeId; } - - inline int32_t getListenerCallsCompletedId() { - return m_ListenerCallsCompletedId; - } - - inline int32_t getListenerCallTimeId() { return m_ListenerCallTimeId; } - - inline int32_t getClearsId() { return m_clearsId; } + static constexpr const char* STATS_NAME = "RegionStatistics"; + static constexpr const char* STATS_DESC = "Statistics for this region"; }; + } // namespace client } // namespace geode } // namespace apache http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RegionXmlCreation.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RegionXmlCreation.cpp b/src/cppcache/src/RegionXmlCreation.cpp index 37de2e0..8b234d0 100644 --- a/src/cppcache/src/RegionXmlCreation.cpp +++ b/src/cppcache/src/RegionXmlCreation.cpp @@ -20,9 +20,9 @@ #include "RegionXmlCreation.hpp" #include "CacheImpl.hpp" using namespace apache::geode::client; -extern bool Cache_CreatedFromCacheFactory; -void RegionXmlCreation::addSubregion(RegionXmlCreation* regionPtr) { +void RegionXmlCreation::addSubregion( + std::shared_ptr<RegionXmlCreation> regionPtr) { subRegions.push_back(regionPtr); } @@ -33,11 +33,8 @@ void RegionXmlCreation::setAttributes(RegionAttributesPtr attrsPtr) { RegionAttributesPtr RegionXmlCreation::getAttributes() { return regAttrs; } void RegionXmlCreation::fillIn(RegionPtr regionPtr) { - std::vector<RegionXmlCreation*>::iterator start = subRegions.begin(); - while (start != subRegions.end()) { - RegionXmlCreation* regXmlCreation = *start; + for (const auto& regXmlCreation : subRegions) { regXmlCreation->create(regionPtr); - start++; } } @@ -45,23 +42,6 @@ void RegionXmlCreation::createRoot(Cache* cache) { GF_D_ASSERT(this->isRoot); RegionPtr rootRegPtr = nullptr; - if (Cache_CreatedFromCacheFactory) { - // if(cache->m_cacheImpl->getDefaultPool() == nullptr) - { - // we may need to initialize default pool - if (regAttrs->getEndpoints() == nullptr) { - if (regAttrs->getPoolName() == nullptr) { - PoolPtr pool = CacheFactory::createOrGetDefaultPool(); - - if (pool == nullptr) { - throw IllegalStateException("Pool is not defined create region."); - } - regAttrs->setPoolName(pool->getName()); - } - } - } - } - CacheImpl* cacheImpl = CacheRegionHelper::getCacheImpl(cache); cacheImpl->createRegion(regionName.c_str(), regAttrs, rootRegPtr); fillIn(rootRegPtr); @@ -83,15 +63,6 @@ RegionXmlCreation::RegionXmlCreation(char* name, bool isRootRegion) attrId = ""; } -RegionXmlCreation::~RegionXmlCreation() { - std::vector<RegionXmlCreation*>::iterator start = subRegions.begin(); - while (start != subRegions.end()) { - delete *start; - *start = nullptr; - ++start; - } -} - std::string RegionXmlCreation::getAttrId() const { return attrId; } void RegionXmlCreation::setAttrId(const std::string& pattrId) { http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RegionXmlCreation.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RegionXmlCreation.hpp b/src/cppcache/src/RegionXmlCreation.hpp index 0c31425..a0bd853 100644 --- a/src/cppcache/src/RegionXmlCreation.hpp +++ b/src/cppcache/src/RegionXmlCreation.hpp @@ -57,7 +57,7 @@ class CPPCACHE_EXPORT RegionXmlCreation { RegionAttributesPtr regAttrs; /** This region's subregions */ - std::vector<RegionXmlCreation*> subRegions; + std::vector<std::shared_ptr<RegionXmlCreation>> subRegions; public: /** @@ -69,7 +69,7 @@ class CPPCACHE_EXPORT RegionXmlCreation { void fillIn(RegionPtr region); public: - ~RegionXmlCreation(); + ~RegionXmlCreation() = default; /** * Creates a new <code>RegionCreation</code> with the given name. */ @@ -78,7 +78,7 @@ class CPPCACHE_EXPORT RegionXmlCreation { /** * Adds a subregion with the given name to this region */ - void addSubregion(RegionXmlCreation* regionPtr); + void addSubregion(std::shared_ptr<RegionXmlCreation> regionPtr); /** * Sets the attributes of this region http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RemoteQuery.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RemoteQuery.cpp b/src/cppcache/src/RemoteQuery.cpp index 2c37595..b8450f5 100644 --- a/src/cppcache/src/RemoteQuery.cpp +++ b/src/cppcache/src/RemoteQuery.cpp @@ -70,7 +70,13 @@ SelectResultsPtr RemoteQuery::execute(uint32_t timeout, const char* func, pool->getStats().incQueryExecutionId(); } /*get the start time for QueryExecutionTime stat*/ - int64_t sampleStartNanos = Utils::startStatOpTime(); + bool enableTimeStatistics = pool->getConnectionManager() + .getCacheImpl() + ->getDistributedSystem() + .getSystemProperties() + .getEnableTimeStatistics(); + int64_t sampleStartNanos = + enableTimeStatistics ? Utils::startStatOpTime() : 0; TcrMessageReply reply(true, tcdm); ChunkedQueryResponse* resultCollector = (new ChunkedQueryResponse(reply)); reply.setChunkedResultHandler( @@ -105,11 +111,10 @@ SelectResultsPtr RemoteQuery::execute(uint32_t timeout, const char* func, } /*update QueryExecutionTime stat */ - if (pool != nullptr) { - Utils::updateStatOpTime( - pool->getStats().getStats(), - PoolStatType::getInstance()->getQueryExecutionTimeId(), - sampleStartNanos); + if (pool != nullptr && enableTimeStatistics) { + Utils::updateStatOpTime(pool->getStats().getStats(), + pool->getStats().getQueryExecutionTimeId(), + sampleStartNanos); } delete resultCollector; return sr; @@ -130,6 +135,10 @@ GfErrType RemoteQuery::executeNoThrow(uint32_t timeout, TcrMessageReply& reply, if (paramList != nullptr) { // QUERY_WITH_PARAMETERS TcrMessageQueryWithParameters msg( + m_tccdm->getConnectionManager() + .getCacheImpl() + ->getCache() + ->createDataOutput(), m_queryString, nullptr, paramList, static_cast<int>(timeout * 1000) /* in milli second */, tcdm); msg.setTimeout(timeout); @@ -152,7 +161,11 @@ GfErrType RemoteQuery::executeNoThrow(uint32_t timeout, TcrMessageReply& reply, } return err; } else { - TcrMessageQuery msg(m_queryString, + TcrMessageQuery msg(m_tccdm->getConnectionManager() + .getCacheImpl() + ->getCache() + ->createDataOutput(), + m_queryString, static_cast<int>(timeout * 1000) /* in milli second */, tcdm); msg.setTimeout(timeout); http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RemoteQueryService.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RemoteQueryService.cpp b/src/cppcache/src/RemoteQueryService.cpp index 095c7e7..d46e1b3 100644 --- a/src/cppcache/src/RemoteQueryService.cpp +++ b/src/cppcache/src/RemoteQueryService.cpp @@ -21,20 +21,23 @@ #include "CqServiceVsdStats.hpp" #include "ThinClientPoolDM.hpp" #include "UserAttributes.hpp" +#include "statistics/StatisticsManager.hpp" using namespace apache::geode::client; -RemoteQueryService::RemoteQueryService(CacheImpl* cptr, +RemoteQueryService::RemoteQueryService(CacheImpl* cache, ThinClientPoolDM* poolDM) - : m_invalid(true), m_cqService(nullptr) { + : m_invalid(true), + m_cqService(nullptr), + m_statisticsFactory(cache->getDistributedSystem() + .getStatisticsManager() + ->getStatisticsFactory()) { if (poolDM) { m_tccdm = poolDM; } else { m_tccdm = - new ThinClientCacheDistributionManager(cptr->tcrConnectionManager()); + new ThinClientCacheDistributionManager(cache->tcrConnectionManager()); } - // m_cqService = new CqService(m_tccdm); - // m_tccdm->init(); LOGFINEST("Initialized m_tccdm"); } @@ -242,10 +245,10 @@ CqServiceStatisticsPtr RemoteQueryService::getCqServiceStatistics() { "QueryService::getCqServiceStatistics: Cache has been closed."); } // If cqService has not started, then no cq exists - if (m_cqService != nullptr) { + if (m_cqService) { return m_cqService->getCqServiceStatistics(); } - return std::make_shared<CqServiceVsdStats>(); + return nullptr; } void RemoteQueryService::receiveNotification(TcrMessage* msg) { http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/RemoteQueryService.hpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/RemoteQueryService.hpp b/src/cppcache/src/RemoteQueryService.hpp index ec9567d..feca89c 100644 --- a/src/cppcache/src/RemoteQueryService.hpp +++ b/src/cppcache/src/RemoteQueryService.hpp @@ -1,8 +1,3 @@ -#pragma once - -#ifndef GEODE_REMOTEQUERYSERVICE_H_ -#define GEODE_REMOTEQUERYSERVICE_H_ - /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with @@ -19,14 +14,20 @@ * See the License for the specific language governing permissions and * limitations under the License. */ + +#pragma once + +#ifndef GEODE_REMOTEQUERYSERVICE_H_ +#define GEODE_REMOTEQUERYSERVICE_H_ + +#include <ace/Recursive_Thread_Mutex.h> #include <geode/geode_globals.hpp> #include <memory> -#include "CqService.hpp" - #include <geode/QueryService.hpp> -#include "ThinClientCacheDistributionManager.hpp" -#include <ace/Recursive_Thread_Mutex.h> +#include "CqService.hpp" +#include "ThinClientCacheDistributionManager.hpp" +#include "statistics/StatisticsManager.hpp" namespace apache { namespace geode { @@ -73,7 +74,7 @@ class CPPCACHE_EXPORT RemoteQueryService inline void initCqService() { if (m_cqService == nullptr) { LOGFINE("RemoteQueryService: starting cq service"); - m_cqService = std::make_shared<CqService>(m_tccdm); + m_cqService = std::make_shared<CqService>(m_tccdm, m_statisticsFactory); LOGFINE("RemoteQueryService: started cq service"); } } @@ -85,6 +86,7 @@ class CPPCACHE_EXPORT RemoteQueryService ThinClientBaseDM* m_tccdm; CqServicePtr m_cqService; CqPoolsConnected m_CqPoolsConnected; + statistics::StatisticsFactory* m_statisticsFactory; }; typedef std::shared_ptr<RemoteQueryService> RemoteQueryServicePtr; http://git-wip-us.apache.org/repos/asf/geode-native/blob/da389793/src/cppcache/src/Serializable.cpp ---------------------------------------------------------------------- diff --git a/src/cppcache/src/Serializable.cpp b/src/cppcache/src/Serializable.cpp index db2d17a..143385d 100644 --- a/src/cppcache/src/Serializable.cpp +++ b/src/cppcache/src/Serializable.cpp @@ -20,6 +20,7 @@ #include <SerializationRegistry.hpp> #include <Utils.hpp> #include <geode/CacheableString.hpp> +#include "CacheImpl.hpp" namespace apache { namespace geode { @@ -42,18 +43,6 @@ int8_t Serializable::DSFID() const { uint32_t Serializable::objectSize() const { return 0; } -void Serializable::registerType(TypeFactoryMethod creationFunction) { - SerializationRegistry::addType(creationFunction); -} - -void Serializable::registerPdxType(TypeFactoryMethodPdx creationFunction) { - SerializationRegistry::addPdxType(creationFunction); -} - -void Serializable::registerPdxSerializer(PdxSerializerPtr pdxSerializer) { - SerializationRegistry::setPdxSerializer(pdxSerializer); -} - CacheableStringPtr Serializable::toString() const { return Utils::demangleTypeName(typeid(*this).name()); }
