| /* |
| * 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_INTEGRATION_TEST_CACHEHELPER_H_ |
| #define GEODE_INTEGRATION_TEST_CACHEHELPER_H_ |
| |
| #include <list> |
| #include <chrono> |
| #include <cstdlib> |
| |
| #include <ace/OS.h> |
| #include <ace/INET_Addr.h> |
| #include <ace/SOCK_Acceptor.h> |
| |
| #include <geode/SystemProperties.hpp> |
| #include <geode/PoolManager.hpp> |
| |
| #include "TimeBomb.hpp" |
| #include "DistributedSystemImpl.hpp" |
| #include "Utils.hpp" |
| #include "config.h" |
| |
| #ifndef ROOT_NAME |
| #define ROOT_NAME "Root" |
| #endif |
| |
| #ifndef ROOT_SCOPE |
| #define ROOT_SCOPE LOCAL |
| #endif |
| |
| namespace apache { |
| namespace geode { |
| namespace client { |
| |
| class CacheHelper { |
| public: |
| static CacheHelper* singleton; |
| static std::list<std::string> staticConfigFileList; |
| std::shared_ptr<Cache> cachePtr; |
| std::shared_ptr<Region> rootRegionPtr; |
| |
| std::shared_ptr<Cache> getCache(); |
| |
| static CacheHelper& getHelper(); |
| |
| static void resetHelper(); |
| |
| static std::string unitTestOutputFile(); |
| static int getNumLocatorListUpdates(const char* s); |
| |
| explicit CacheHelper(const char* member_id, |
| const std::shared_ptr<Properties>& configPtr = nullptr, |
| const bool noRootRegion = false); |
| |
| /** rootRegionPtr will still be null... */ |
| CacheHelper(const char* member_id, const char* cachexml, |
| const std::shared_ptr<Properties>& configPtr = nullptr); |
| |
| explicit CacheHelper(const std::shared_ptr<Properties>& configPtr = nullptr, |
| const bool noRootRegion = false); |
| |
| explicit CacheHelper(const bool isThinclient, |
| const std::shared_ptr<Properties>& configPtr = nullptr, |
| const bool noRootRegion = false); |
| |
| CacheHelper(const bool isThinclient, |
| const std::shared_ptr<AuthInitialize>& authInitialize, |
| const std::shared_ptr<Properties>& configPtr = nullptr); |
| |
| CacheHelper(const bool isThinclient, bool pdxIgnoreUnreadFields, |
| bool pdxReadSerialized, |
| const std::shared_ptr<Properties>& configPtr = nullptr, |
| const bool noRootRegion = false); |
| |
| CacheHelper(const bool isthinClient, const char* poolName, |
| const char* locators, const char* serverGroup, |
| const std::shared_ptr<Properties>& configPtr = nullptr, |
| int redundancy = 0, bool clientNotification = false, |
| int subscriptionAckInterval = -1, int connections = -1, |
| int loadConditioningInterval = -1, bool isMultiuserMode = false, |
| bool prSingleHop = false, bool threadLocal = false); |
| |
| explicit CacheHelper(const int redundancyLevel, |
| const std::shared_ptr<Properties>& configPtr = nullptr); |
| |
| virtual ~CacheHelper(); |
| |
| void closePool(const char* poolName, bool keepAlive = false); |
| |
| void disconnect(bool keepalive = false); |
| |
| void createPlainRegion(const char* regionName, |
| std::shared_ptr<Region>& regionPtr); |
| |
| void createPlainRegion(const char* regionName, |
| std::shared_ptr<Region>& regionPtr, uint32_t size); |
| |
| void createLRURegion(const char* regionName, |
| std::shared_ptr<Region>& regionPtr); |
| |
| void createLRURegion(const char* regionName, |
| std::shared_ptr<Region>& regionPtr, uint32_t size); |
| |
| void createDistRegion(const char* regionName, |
| std::shared_ptr<Region>& regionPtr); |
| |
| void createDistRegion(const char* regionName, |
| std::shared_ptr<Region>& regionPtr, uint32_t size); |
| |
| std::shared_ptr<Region> getRegion(const std::string& name); |
| |
| std::shared_ptr<Region> createRegion( |
| const char* name, bool ack, bool caching, |
| const std::shared_ptr<CacheListener>& listener, |
| bool clientNotificationEnabled = false, bool scopeLocal = false, |
| bool concurrencyCheckEnabled = false, int32_t tombstonetimeout = -1); |
| |
| std::shared_ptr<Region> createRegion( |
| const char* name, bool ack, bool caching = true, |
| const std::chrono::seconds& ettl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& eit = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rttl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rit = std::chrono::seconds::zero(), |
| int lel = 0, ExpirationAction action = ExpirationAction::DESTROY, |
| const char* endpoints = nullptr, bool clientNotificationEnabled = false); |
| |
| std::shared_ptr<Pool> createPool( |
| const std::string& poolName, const char* locators, |
| const char* serverGroup, int redundancy = 0, |
| bool clientNotification = false, |
| std::chrono::milliseconds subscriptionAckInterval = |
| std::chrono::milliseconds::zero(), |
| int connections = -1, int loadConditioningInterval = -1, |
| bool isMultiuserMode = false); |
| |
| // this will create pool even endpoints and locatorhost has been not defined |
| std::shared_ptr<Pool> createPool2(const char* poolName, const char* locators, |
| const char* serverGroup, |
| const char* servers = nullptr, |
| int redundancy = 0, |
| bool clientNotification = false, |
| int subscriptionAckInterval = -1, |
| int connections = -1); |
| |
| void logPoolAttributes(std::shared_ptr<Pool>& pool); |
| |
| void createPoolWithLocators( |
| const std::string& name, const char* locators = nullptr, |
| bool clientNotificationEnabled = false, int subscriptionRedundancy = -1, |
| std::chrono::milliseconds subscriptionAckInterval = |
| std::chrono::milliseconds::zero(), |
| int connections = -1, bool isMultiuserMode = false, |
| const char* serverGroup = nullptr); |
| |
| std::shared_ptr<Region> createRegionAndAttachPool( |
| const std::string& name, bool ack, const std::string& poolName, |
| bool caching = true, |
| const std::chrono::seconds& ettl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& eit = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rttl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rit = std::chrono::seconds::zero(), |
| int lel = 0, ExpirationAction action = ExpirationAction::DESTROY); |
| |
| std::shared_ptr<Region> createRegionAndAttachPool2( |
| const char* name, bool ack, const char* poolName, |
| const std::shared_ptr<PartitionResolver>& aResolver = nullptr, |
| bool caching = true, |
| const std::chrono::seconds& ettl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& eit = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rttl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rit = std::chrono::seconds::zero(), |
| int lel = 0, ExpirationAction action = ExpirationAction::DESTROY); |
| |
| static void addServerLocatorEPs(const char* epList, PoolFactory& pfPtr, |
| bool poolLocators = true); |
| |
| std::shared_ptr<Region> createPooledRegion( |
| const char* name, bool ack, const char* locators = nullptr, |
| const char* poolName = "__TEST_POOL1__", bool caching = true, |
| bool clientNotificationEnabled = false, |
| const std::chrono::seconds& ettl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& eit = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rttl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rit = std::chrono::seconds::zero(), |
| int lel = 0, |
| const std::shared_ptr<CacheListener>& cacheListener = nullptr, |
| ExpirationAction action = ExpirationAction::DESTROY); |
| |
| std::shared_ptr<Region> createPooledRegionConcurrencyCheckDisabled( |
| const char* name, bool ack, const char* locators = nullptr, |
| const char* poolName = "__TEST_POOL1__", bool caching = true, |
| bool clientNotificationEnabled = false, |
| bool concurrencyCheckEnabled = true, |
| const std::chrono::seconds& ettl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& eit = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rttl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rit = std::chrono::seconds::zero(), |
| int lel = 0, |
| const std::shared_ptr<CacheListener>& cacheListener = nullptr, |
| ExpirationAction action = ExpirationAction::DESTROY); |
| |
| std::shared_ptr<Region> createRegionDiscOverFlow( |
| const char* name, bool caching = true, |
| bool clientNotificationEnabled = false, |
| const std::chrono::seconds& ettl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& eit = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rttl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rit = std::chrono::seconds::zero(), |
| int lel = 0, ExpirationAction action = ExpirationAction::DESTROY); |
| |
| std::shared_ptr<Region> createPooledRegionDiscOverFlow( |
| const char* name, bool ack, const char* locators = nullptr, |
| const char* poolName = "__TEST_POOL1__", bool caching = true, |
| bool clientNotificationEnabled = false, |
| const std::chrono::seconds& ettl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& eit = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rttl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rit = std::chrono::seconds::zero(), |
| int lel = 0, |
| const std::shared_ptr<CacheListener>& cacheListener = nullptr, |
| ExpirationAction action = ExpirationAction::DESTROY); |
| |
| std::shared_ptr<Region> createPooledRegionSticky( |
| const char* name, bool ack, const char* locators = nullptr, |
| const char* poolName = "__TEST_POOL1__", bool caching = true, |
| bool clientNotificationEnabled = false, |
| const std::chrono::seconds& ettl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& eit = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rttl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rit = std::chrono::seconds::zero(), |
| int lel = 0, |
| const std::shared_ptr<CacheListener>& cacheListener = nullptr, |
| ExpirationAction action = ExpirationAction::DESTROY); |
| |
| std::shared_ptr<Region> createPooledRegionStickySingleHop( |
| const char* name, bool ack, const char* locators = nullptr, |
| const char* poolName = "__TEST_POOL1__", bool caching = true, |
| bool clientNotificationEnabled = false, |
| const std::chrono::seconds& ettl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& eit = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rttl = std::chrono::seconds::zero(), |
| const std::chrono::seconds& rit = std::chrono::seconds::zero(), |
| int lel = 0, |
| const std::shared_ptr<CacheListener>& cacheListener = nullptr, |
| ExpirationAction action = ExpirationAction::DESTROY); |
| |
| std::shared_ptr<Region> createSubregion( |
| std::shared_ptr<Region>& parent, const char* name, bool ack, bool caching, |
| const std::shared_ptr<CacheListener>& listener); |
| |
| std::shared_ptr<CacheableString> createCacheable(const char* value); |
| |
| void showKeys(std::vector<std::shared_ptr<CacheableKey>>& vecKeys); |
| |
| void showRegionAttributes(RegionAttributes attributes); |
| |
| std::shared_ptr<QueryService> getQueryService(); |
| |
| /* |
| * GFJAVA is the environment variable. user has to set GFJAVA variable as a |
| * product build directory |
| * path for java cache server or set as endpoints list for the remote server |
| */ |
| |
| static int staticHostPort1; |
| static int staticHostPort2; |
| static int staticHostPort3; |
| static int staticHostPort4; |
| |
| static const std::string getTcrEndpoints(bool& isLocalServer, |
| int numberOfServers = 1); |
| |
| static int staticLocatorHostPort1; |
| static int staticLocatorHostPort2; |
| static int staticLocatorHostPort3; |
| |
| static int staticJmxManagerPort; |
| |
| static const char* getstaticLocatorHostPort1(); |
| |
| static const char* getstaticLocatorHostPort2(); |
| |
| static const char* getLocatorHostPort(int locPort); |
| |
| static const char* getLocatorHostPort(bool& isLocator, bool& isLocalServer, |
| int numberOfLocators = 0); |
| |
| static const std::string getTcrEndpoints2(bool& isLocalServer, |
| int numberOfServers = 1); |
| |
| static std::list<int> staticServerInstanceList; |
| static bool isServerCleanupCallbackRegistered; |
| static void cleanupServerInstances(); |
| |
| static void initServer(int instance, const char* xml = nullptr, |
| const char* locHostport = nullptr, |
| const char* authParam = nullptr, bool ssl = false, |
| bool enableDelta = true, bool multiDS = false, |
| bool testServerGC = false, bool untrustedCert = false, |
| bool useSecurityManager = false); |
| |
| static void createDuplicateXMLFile(std::string& originalFile, int hostport1, |
| int hostport2, int locport1, int locport2); |
| |
| static void createDuplicateXMLFile(std::string& duplicateFile, |
| std::string& originalFile); |
| |
| static void closeServer(int instance); |
| |
| // closing locator |
| static void closeLocator(int instance, bool ssl = false); |
| template <class Rep, class Period> |
| static void terminate_process_file( |
| const std::string& pidFileName, |
| const std::chrono::duration<Rep, Period>& duration); |
| static bool file_exists(const std::string& fileName); |
| static void read_single_line(const std::string& fileName, std::string& str); |
| |
| static void cleanupTmpConfigFiles(); |
| |
| static void replacePortsInFile(int hostPort1, int hostPort2, int hostPort3, |
| int hostPort4, int locPort1, int locPort2, |
| const std::string& inFile, |
| const std::string& outFile); |
| |
| #ifdef _SOLARIS |
| static void replaceInPlace(std::string& searchStr, |
| const std::string& matchStr, |
| const std::string& replaceStr); |
| #endif |
| |
| static std::list<int> staticLocatorInstanceList; |
| static bool isLocatorCleanupCallbackRegistered; |
| static void cleanupLocatorInstances(); |
| |
| // starting locator |
| static void initLocator(int instance, bool ssl = false, bool multiDS = false, |
| int dsId = -1, int remoteLocator = 0, |
| bool untrustedCert = false, |
| bool useSecurityManager = false); |
| |
| static void clearSecProp(); |
| |
| static void setJavaConnectionPoolSize(uint32_t size); |
| |
| static bool isSeedSet; |
| static bool setSeed(); |
| |
| static int hashcode(char* str); |
| |
| static int getRandomNumber(); |
| |
| static int getRandomAvailablePort(); |
| |
| static int staticMcastPort; |
| static int staticMcastAddress; |
| |
| private: |
| static std::string generateGeodeProperties( |
| const std::string& path, const bool ssl = false, const int dsId = -1, |
| const int remoteLocator = 0, const bool untrustedCert = false, |
| const bool useSecurityManager = false); |
| }; |
| |
| #ifndef test_cppcache_utils_static |
| CacheHelper* CacheHelper::singleton = nullptr; |
| std::list<int> CacheHelper::staticServerInstanceList; |
| std::list<int> CacheHelper::staticLocatorInstanceList; |
| std::list<std::string> CacheHelper::staticConfigFileList; |
| bool CacheHelper::isServerCleanupCallbackRegistered = false; |
| bool CacheHelper::isLocatorCleanupCallbackRegistered = false; |
| |
| bool CacheHelper::isSeedSet = CacheHelper::setSeed(); |
| int CacheHelper::staticMcastAddress = CacheHelper::getRandomNumber() % 250 + 3; |
| int CacheHelper::staticMcastPort = CacheHelper::getRandomNumber(); |
| int CacheHelper::staticHostPort1 = CacheHelper::getRandomAvailablePort(); |
| int CacheHelper::staticHostPort2 = CacheHelper::getRandomAvailablePort(); |
| int CacheHelper::staticHostPort3 = CacheHelper::getRandomAvailablePort(); |
| int CacheHelper::staticHostPort4 = CacheHelper::getRandomAvailablePort(); |
| |
| int CacheHelper::staticLocatorHostPort1 = CacheHelper::getRandomAvailablePort(); |
| int CacheHelper::staticLocatorHostPort2 = CacheHelper::getRandomAvailablePort(); |
| int CacheHelper::staticLocatorHostPort3 = CacheHelper::getRandomAvailablePort(); |
| |
| int CacheHelper::staticJmxManagerPort = CacheHelper::getRandomAvailablePort(); |
| |
| #endif |
| |
| } // namespace client |
| } // namespace geode |
| } // namespace apache |
| |
| #endif // GEODE_INTEGRATION_TEST_CACHEHELPER_H_ |