/*=========================================================================
 * Copyright (c) 2010-2014 Pivotal Software, Inc. All Rights Reserved.
 * This product is protected by U.S. and international copyright
 * and intellectual property laws. Pivotal products are covered by
 * one or more patents listed at http://www.pivotal.io/patents.
 *=========================================================================
 */
#include <gfcpp/GemfireCppCache.hpp>
#include <stdlib.h>
#include <gfcpp/SystemProperties.hpp>
#include <ace/OS.h>
#include <ace/INET_Addr.h>
#include <ace/SOCK_Acceptor.h>

#include "TimeBomb.hpp"
#include <list>
#include "DistributedSystemImpl.hpp"
#include "Utils.hpp"
#include "PoolManager.hpp"

#include "CacheHelper.hpp"
#define __DUNIT_NO_MAIN__
#include "fw_dunit.hpp"

#ifndef ROOT_NAME
#define ROOT_NAME "Root"
#endif

#ifndef ROOT_SCOPE
#define ROOT_SCOPE LOCAL
#endif

#if defined(WIN32)
#define GFSH "gfsh.bat"
#define COPY_COMMAND "copy /y"
#define DELETE_COMMAND "del /f"
#define PATH_SEP "\\"
#else
#define GFSH "gfsh"
#define COPY_COMMAND "cp -f"
#define DELETE_COMMAND "rm -f"
#define PATH_SEP "/"
#endif

using namespace gemfire;

extern ClientCleanup gClientCleanup;

#define SEED 0
#define RANDOM_NUMBER_OFFSET 14000
#define RANDOM_NUMBER_DIVIDER 15000

CachePtr CacheHelper::getCache()
  {
    return cachePtr;
  }
  
  CacheHelper& CacheHelper::getHelper()
  {
    if ( singleton == NULL ) {
      singleton = new CacheHelper();
    }
    return *singleton;
  }

  CacheHelper::CacheHelper(const char* member_id,
              const PropertiesPtr& configPtr,
              const bool noRootRegion)
  {
    PropertiesPtr pp = configPtr;
    if (pp == NULLPTR) {
       pp = Properties::create();
    }

    cachePtr = CacheFactory::createCacheFactory(pp)->create();
    
    m_doDisconnect = false;
    
    if(noRootRegion) return;
    
    try {
      RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(CACHING_PROXY);
      rootRegionPtr = regionFactoryPtr->create(ROOT_NAME);
    } catch (const RegionExistsException &) {
      rootRegionPtr = cachePtr->getRegion(ROOT_NAME);
    }
    
    showRegionAttributes(*rootRegionPtr->getAttributes());
  }

  /** rootRegionPtr will still be null... */
  CacheHelper::CacheHelper(const char* member_id, const char* cachexml,
              const PropertiesPtr& configPtr)
  {
    PropertiesPtr pp = configPtr;
    if (pp == NULLPTR) {
       pp = Properties::create();
    }
    if(cachexml != NULL)
    {
      std::string tmpXmlFile(cachexml);
      std::string newFile;
      CacheHelper::createDuplicateXMLFile(newFile, tmpXmlFile);
      pp->insert("cache-xml-file", newFile.c_str());
    }
    cachePtr = CacheFactory::createCacheFactory(pp)->create();
    
    m_doDisconnect = false;
  }

  CacheHelper::CacheHelper(const PropertiesPtr& configPtr,
              const bool noRootRegion)
  {
    PropertiesPtr pp = configPtr;
    if (pp == NULLPTR) {
       pp = Properties::create();
    }
    
    cachePtr = CacheFactory::createCacheFactory(pp)->create();
    
    m_doDisconnect = false;
    
    if(noRootRegion) return;
    
    try {
      RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(CACHING_PROXY);
      rootRegionPtr = regionFactoryPtr->create(ROOT_NAME);
    } catch (const RegionExistsException &) {
      rootRegionPtr = cachePtr->getRegion(ROOT_NAME);
    }
    
    showRegionAttributes(*rootRegionPtr->getAttributes());
  }

  CacheHelper::CacheHelper(const bool isThinclient,
              const PropertiesPtr& configPtr ,
              const bool noRootRegion)
  {
    PropertiesPtr pp = configPtr;
    if (pp == NULLPTR) {
       pp = Properties::create();
    }
    try {
      LOG("hitesh in cachehelper before createCacheFactory");
      cachePtr = CacheFactory::createCacheFactory(pp)->create();
      m_doDisconnect = false;
    } catch (const Exception & excp) {
      LOG("GemFire exception while creating cache, logged in following line");
      LOG(excp.getMessage());
    } catch (...) {
      LOG("Throwing exception while creating cache....");
    }
  }

  CacheHelper::CacheHelper(const bool isThinclient, bool pdxIgnoreUnreadFields, bool pdxReadSerialized,
              const PropertiesPtr& configPtr,
              const bool noRootRegion)
  {    
    PropertiesPtr pp = configPtr;
    if (pp == NULLPTR) {
       pp = Properties::create();
    }
    try {      
      CacheFactoryPtr cfPtr = CacheFactory::createCacheFactory(pp);
      LOGINFO("pdxReadSerialized = %d ", pdxReadSerialized);
      LOGINFO("pdxIgnoreUnreadFields = %d ", pdxIgnoreUnreadFields);
      cfPtr->setPdxReadSerialized(pdxReadSerialized);
      cfPtr->setPdxIgnoreUnreadFields(pdxIgnoreUnreadFields);
      cachePtr = cfPtr->create();
      m_doDisconnect = false;
    } catch (const Exception & excp) {
      LOG("GemFire exception while creating cache, logged in following line");
      LOG(excp.getMessage());
    } catch (...) {
      LOG("Throwing exception while creating cache....");
    }
  }

  CacheHelper::CacheHelper(const bool isthinClient, const char* poolName,
      const char* locators, const char* serverGroup,
      const char* servers, const PropertiesPtr& configPtr,
      int redundancy, bool clientNotification,
      int subscriptionAckInterval, int connections,
      int loadConditioningInterval, bool isMultiuserMode, bool prSingleHop, bool threadLocal) {
    PropertiesPtr pp = configPtr;
    if (pp == NULLPTR) {
      pp = Properties::create();
    }

    try {
      CacheFactoryPtr cacheFac = CacheFactory::createCacheFactory(pp);
      cacheFac->setPRSingleHopEnabled(prSingleHop);
      cacheFac->setThreadLocalConnections(threadLocal);
      printf(" Setting pr-single-hop to prSingleHop = %d ", prSingleHop);
      printf("Setting threadLocal to %d ", threadLocal);
      if (servers != 0)//with explicit server list
      {
        addServerLocatorEPs(servers, cacheFac, false);
        //do region creation with end
      } else if (locators != 0) //with locator
      {
        addServerLocatorEPs(locators, cacheFac);
        if (serverGroup) {
          cacheFac->setServerGroup(serverGroup);
        }
      } else //neither server nor locator return NULLPTR
      {
        // return PoolPtr(NULLPTR);
      }
      cacheFac->setSubscriptionRedundancy(redundancy);
      cacheFac->setSubscriptionEnabled(clientNotification);
      cacheFac->setMultiuserAuthentication(isMultiuserMode);
      //poolFacPtr->setStatisticInterval(1000);
      if (loadConditioningInterval > 0) {
        cacheFac->setLoadConditioningInterval(loadConditioningInterval);
      }
      printf("Setting connections to %d ", connections);
      if (connections >= 0) {
        cacheFac->setMinConnections(connections);
        cacheFac->setMaxConnections(connections);
      }
      if (subscriptionAckInterval != -1) {
        cacheFac->setSubscriptionAckInterval(subscriptionAckInterval);
      }

      cachePtr = cacheFac->create();
    } catch (const Exception & excp) {
      LOG("GemFire exception while creating cache, logged in following line");
      LOG(excp.getMessage());
    } catch (...) {
      LOG("Throwing exception while creating cache....");
    }
  }

  CacheHelper::CacheHelper(const char* endpoints, const int redundancyLevel,
      const PropertiesPtr& configPtr)
  {
    PropertiesPtr pp = configPtr;
    if ( pp == NULLPTR ) {
      pp = Properties::create( );
    }

    // This is specifically setting cache-level endpoints (old endpoints case, deprecated) so we don't place the new cache API here

    DistributedSystemPtr systemPtr = DistributedSystem::connect( ROOT_NAME, pp );
    CacheAttributesFactory cFact;
    cFact.setEndpoints( endpoints );
    cFact.setRedundancyLevel( redundancyLevel );
    CacheAttributesPtr cAttrs = cFact.createCacheAttributes( );
    cachePtr = CacheFactory::create( "aName", systemPtr, cAttrs );
    m_doDisconnect = true;
  }

   CacheHelper::~CacheHelper( )
  {
   // CacheHelper::cleanupTmpConfigFiles();
    disconnect();
  }

  void CacheHelper::closePool(const char* poolName, bool keepAlive)
  {
    PoolPtr pool = PoolManager::find(poolName);
    pool->destroy(keepAlive);
  }

  void CacheHelper::disconnect(bool keepalive)
  {
    if (cachePtr == NULLPTR) {
      return;
    }

    LOG( "Beginning cleanup after CacheHelper." );

    DistributedSystemPtr systemPtr;
    if (m_doDisconnect) {
      systemPtr = cachePtr->getDistributedSystem();
    }
    
    // rootRegionPtr->localDestroyRegion();
    rootRegionPtr = NULLPTR;
    LOG( "Destroyed root region." );
    try {
    LOG( "Closing cache." );
      if (cachePtr != NULLPTR) {
        cachePtr->close(keepalive);
      }
    LOG( "Closing cache complete." );
    }
    catch ( Exception& ex ) {
      LOG( "Exception thrown while closing cache: " );
      LOG( ex.getMessage( ) );
    }
    catch ( ... ) {
      LOG("exception throw while closing cache");
    }

    cachePtr = NULLPTR;
    LOG( "Closed cache." );
    try {
      if (m_doDisconnect) {
        LOG( "Disconnecting..." );
        systemPtr->disconnect();
        LOG( "Finished disconnect." );
      }
    } catch ( ... ) {
      LOG("Throwing exception while disconnecting....");
    }
    singleton = NULL;
    LOG( "Finished cleanup after CacheHelper." );
  }

  void CacheHelper::createPlainRegion( const char* regionName, RegionPtr& regionPtr )
  {
    createPlainRegion( regionName, regionPtr, 10 );
  }

  void CacheHelper::createPlainRegion( const char* regionName, RegionPtr& regionPtr, uint32_t size )
  {
    RegionAttributesPtr regAttrs;
    AttributesFactory attrFactory;
    // set lru attributes...
    attrFactory.setLruEntriesLimit( 0 ); // no limit.
    attrFactory.setInitialCapacity( size ); // no limit.
    // then...
    attrFactory.setScope(ScopeType::LOCAL);
    regAttrs = attrFactory.createRegionAttributes( );
    showRegionAttributes( *regAttrs );
    // This is using subregions (deprecated) so not placing the new cache API here
    regionPtr = rootRegionPtr->createSubregion( regionName, regAttrs );
    ASSERT( regionPtr != NULLPTR, "failed to create region." );
  }

  void CacheHelper::createLRURegion( const char* regionName, RegionPtr& regionPtr )
  {
    createLRURegion( regionName, regionPtr, 10 );
  }
  void CacheHelper::createLRURegion( const char* regionName, RegionPtr& regionPtr, uint32_t size )
  {
    RegionAttributesPtr regAttrs;
    AttributesFactory attrFactory;
    // set lru attributes...
    attrFactory.setLruEntriesLimit( size );
    attrFactory.setInitialCapacity( size );
    // then...
    attrFactory.setScope( ScopeType::LOCAL );
    regAttrs = attrFactory.createRegionAttributes( );
    showRegionAttributes( *regAttrs );
    // This is using subregions (deprecated) so not placing the new cache API here
    regionPtr = rootRegionPtr->createSubregion( regionName, regAttrs );
    ASSERT( regionPtr != NULLPTR, "failed to create region." );
  }

  void CacheHelper::createDistRegion( const char* regionName, RegionPtr& regionPtr )
  {
    createDistRegion( regionName, regionPtr, 10 );
  }

  void CacheHelper::createDistRegion( const char* regionName, RegionPtr& regionPtr, uint32_t size )
  {
    RegionAttributesPtr regAttrs;
    AttributesFactory attrFactory;
    // set lru attributes...
    attrFactory.setLruEntriesLimit( 0 ); // no limit.
    attrFactory.setInitialCapacity( size ); // no limit.
    // then...
    attrFactory.setScope(ScopeType::DISTRIBUTED_ACK);
    regAttrs = attrFactory.createRegionAttributes( );
    showRegionAttributes( *regAttrs );
    // This is using subregions (deprecated) so not placing the new cache API here
    regionPtr = rootRegionPtr->createSubregion( regionName, regAttrs );
    ASSERT( regionPtr != NULLPTR, "failed to create region." );
  }

  RegionPtr CacheHelper::getRegion( const char* name )
  {
    return cachePtr->getRegion( name );
  }

  RegionPtr CacheHelper::createRegion( const char* name, bool ack, bool caching, const CacheListenerPtr& listener, const char* endpoints, bool clientNotificationEnabled,
                          bool scopeLocal, bool concurrencyCheckEnabled, int32_t tombstonetimeout)
  {
    AttributesFactory af;
    if (scopeLocal)
      af.setScope( ScopeType::LOCAL);
    else
      af.setScope( ack ? ScopeType::DISTRIBUTED_ACK : ScopeType::DISTRIBUTED_NO_ACK );
    af.setCachingEnabled( caching );
    if ( listener != NULLPTR ) {
      af.setCacheListener( listener );
    }
    // This is setting region level EPs (deprecated old endpoints API) thus not placing the new cache API here
    if( endpoints != 0)
    {
      af.setEndpoints(endpoints);
    }
    af.setClientNotificationEnabled(clientNotificationEnabled);
    if (concurrencyCheckEnabled)
      af.setConcurrencyChecksEnabled(concurrencyCheckEnabled);

    RegionAttributesPtr rattrsPtr = af.createRegionAttributes( );

    return cachePtr->createRegion( name, rattrsPtr );

  }

  RegionPtr CacheHelper::createRegion( const char* name, bool ack,  bool caching , int ettl, int eit, int rttl , int rit ,int lel ,
                          ExpirationAction::Action action , const char* endpoints,
                          bool clientNotificationEnabled )
  {
    AttributesFactory af;
    af.setScope( ack ? ScopeType::DISTRIBUTED_ACK : ScopeType::DISTRIBUTED_NO_ACK );
    af.setCachingEnabled( caching );
    af.setLruEntriesLimit(lel);
    af.setEntryIdleTimeout(action, eit);
    af.setEntryTimeToLive(action, ettl);
    af.setRegionIdleTimeout(action, rit);
    af.setRegionTimeToLive(action, rttl);

    // This is setting region level EPs (deprecated old endpoints API) thus not placing the new cache API here
    if( endpoints != 0)
    {
      af.setEndpoints(endpoints);
    }
    af.setClientNotificationEnabled(clientNotificationEnabled);
    RegionAttributesPtr rattrsPtr = af.createRegionAttributes( );

    return cachePtr->createRegion( name, rattrsPtr );
  }

  PoolPtr  CacheHelper::createPool(const char* poolName, const char* locators, const char* serverGroup,
                      const char* servers, int redundancy, bool clientNotification, int subscriptionAckInterval,
                      int connections, int loadConditioningInterval, bool isMultiuserMode )
  {
    //printf("hitesh in createPool isMultiuserMode = %d \n", isMultiuserMode);
    PoolFactoryPtr poolFacPtr = PoolManager::createFactory();

    if( servers != 0 )//with explicit server list
    {
      addServerLocatorEPs( servers, poolFacPtr, false );
      //do region creation with end
    }
    else if(locators != 0) //with locator
    {
      addServerLocatorEPs( locators, poolFacPtr );
      if(serverGroup){
        poolFacPtr->setServerGroup(serverGroup);
      }
    }
    else //neither server nor locator return NULLPTR
    {
      return PoolPtr( NULLPTR);
    }
    poolFacPtr->setSubscriptionRedundancy(redundancy);
    poolFacPtr->setSubscriptionEnabled(clientNotification);
    poolFacPtr->setMultiuserAuthentication(isMultiuserMode);
    //poolFacPtr->setStatisticInterval(1000);
    if(loadConditioningInterval > 0)
    {
      poolFacPtr->setLoadConditioningInterval(loadConditioningInterval);
    }

    if (connections >= 0) {
      poolFacPtr->setMinConnections(connections);
      poolFacPtr->setMaxConnections(connections);
    }
    if ( subscriptionAckInterval != -1 ) {
      poolFacPtr->setSubscriptionAckInterval( subscriptionAckInterval );
    }

    return poolFacPtr->create(poolName);
  }

  //this will create pool even endpoints and locatorhost has been not defined
  PoolPtr  CacheHelper::createPool2(const char* poolName, const char* locators, const char* serverGroup,
                      const char* servers, int redundancy, bool clientNotification, int subscriptionAckInterval,
                      int connections)
  {
    PoolFactoryPtr poolFacPtr = PoolManager::createFactory();

    if( servers != 0 )//with explicit server list
    {
      addServerLocatorEPs( servers, poolFacPtr, false );
      //do region creation with end
    }
    else if(locators != 0) //with locator
    {
      addServerLocatorEPs( locators, poolFacPtr );
      if(serverGroup){
        poolFacPtr->setServerGroup(serverGroup);
      }
    }

    poolFacPtr->setSubscriptionRedundancy(redundancy);
    poolFacPtr->setSubscriptionEnabled(clientNotification);
    if (connections >= 0) {
      poolFacPtr->setMinConnections(connections);
      poolFacPtr->setMaxConnections(connections);
    }
    if ( subscriptionAckInterval != -1 ) {
      poolFacPtr->setSubscriptionAckInterval( subscriptionAckInterval );
    }

    return poolFacPtr->create(poolName);
  }

  void CacheHelper::logPoolAttributes(PoolPtr & pool)
  {
    LOG("logPoolAttributes() entered");
    LOGINFO("CPPTEST: Pool attribtes for pool %s are as follows:", pool->getName());
    LOGINFO("getFreeConnectionTimeout: %d", pool->getFreeConnectionTimeout());
    LOGINFO("getLoadConditioningInterval: %d", pool->getLoadConditioningInterval());
    LOGINFO("getSocketBufferSize: %d", pool->getSocketBufferSize());
    LOGINFO("getReadTimeout: %d", pool->getReadTimeout());
    LOGINFO("getMinConnections: %d", pool->getMinConnections());
    LOGINFO("getMaxConnections: %d", pool->getMaxConnections());
    LOGINFO("getIdleTimeout: %d", pool->getIdleTimeout());
    LOGINFO("getPingInterval: %d", pool->getPingInterval());
    LOGINFO("getStatisticInterval: %d", pool->getStatisticInterval());
    LOGINFO("getRetryAttempts: %d", pool->getRetryAttempts());
    LOGINFO("getSubscriptionEnabled: %s", pool->getSubscriptionEnabled()?"true":"false");
    LOGINFO("getSubscriptionRedundancy: %d", pool->getSubscriptionRedundancy());
    LOGINFO("getSubscriptionMessageTrackingTimeout: %d", pool->getSubscriptionMessageTrackingTimeout());
    LOGINFO("getSubscriptionAckInterval: %d", pool->getSubscriptionAckInterval());
    LOGINFO("getServerGroup: %s", pool->getServerGroup());
    LOGINFO("getThreadLocalConnections: %s", pool->getThreadLocalConnections()?"true":"false");
    LOGINFO("getPRSingleHopEnabled: %s", pool->getPRSingleHopEnabled()?"true":"false");
  }
  
  void CacheHelper::createPoolWithLocators( const char* name, const char* locators, bool clientNotificationEnabled ,
                 int subscriptionRedundancy, int subscriptionAckInterval , int connections  ,bool isMultiuserMode  ,const char* serverGroup )
  {
    LOG( "createPool() entered." );
    printf("HItesh in createPoolWithLocators isMultiuserMode = %d\n",isMultiuserMode);  
    PoolPtr poolPtr = createPool( name, locators, serverGroup, NULL,
        subscriptionRedundancy, clientNotificationEnabled, subscriptionAckInterval, connections, -1, isMultiuserMode );
    ASSERT(poolPtr != NULLPTR, "Failed to create pool.");
    logPoolAttributes(poolPtr);
    LOG( "Pool created." );
  }
  void CacheHelper::createPoolWithEPs( const char* name, const char* endpoints , bool clientNotificationEnabled ,
                 int subscriptionRedundancy , int subscriptionAckInterval , int connections, bool isMultiuserMode  )
  {
    LOG( "createPool() entered." );
    printf("HItesh in createPoolWithEPs isMultiuserMode = %d\n",isMultiuserMode);
    PoolPtr poolPtr = createPool( name, NULL, NULL, endpoints,
        subscriptionRedundancy, clientNotificationEnabled, subscriptionAckInterval, connections, -1, isMultiuserMode );
    ASSERT(poolPtr != NULLPTR, "Failed to create pool.");
    logPoolAttributes(poolPtr);
    LOG( "Pool created." );
  }
  RegionPtr CacheHelper::createRegionAndAttachPool(const char* name, bool ack, const char* poolName, bool caching ,
                              int ettl, int eit, int rttl, int rit,int lel ,
                              ExpirationAction::Action action       )
  {
    RegionShortcut preDefRA = PROXY;
    if (caching) {
      preDefRA = CACHING_PROXY;
    }
    if (lel > 0) {
      preDefRA = CACHING_PROXY_ENTRY_LRU;
    }
    RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
    regionFactoryPtr->setLruEntriesLimit(lel);
    regionFactoryPtr->setEntryIdleTimeout(action, eit);
    regionFactoryPtr->setEntryTimeToLive(action, ettl);
    regionFactoryPtr->setRegionIdleTimeout(action, rit);
    regionFactoryPtr->setRegionTimeToLive(action, rttl);
    if(poolName != NULL) {
      regionFactoryPtr->setPoolName(poolName);
    }
    return regionFactoryPtr->create(name);
  }

    RegionPtr CacheHelper::createRegionAndAttachPool2(const char* name, bool ack, const char* poolName, const PartitionResolverPtr& aResolver , bool caching,
                              int ettl, int eit , int rttl , int rit ,int lel ,
                              ExpirationAction::Action action )
  {
    RegionShortcut preDefRA = PROXY;
    if (caching) {
      preDefRA = CACHING_PROXY;
    }
    if (lel > 0) {
      preDefRA = CACHING_PROXY_ENTRY_LRU;
    }
    RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
    regionFactoryPtr->setLruEntriesLimit(lel);
    regionFactoryPtr->setEntryIdleTimeout(action, eit);
    regionFactoryPtr->setEntryTimeToLive(action, ettl);
    regionFactoryPtr->setRegionIdleTimeout(action, rit);
    regionFactoryPtr->setRegionTimeToLive(action, rttl);
    regionFactoryPtr->setPoolName(poolName);
    regionFactoryPtr->setPartitionResolver(aResolver);
    return regionFactoryPtr->create(name);
  }

  void CacheHelper::addServerLocatorEPs( const char* epList, PoolFactoryPtr pfPtr, bool poolLocators )
  {
    std::unordered_set<std::string> endpointNames;
    Utils::parseEndpointNamesString(epList, endpointNames);
    for (std::unordered_set<std::string>::iterator iter = endpointNames.begin(); iter
        != endpointNames.end(); ++iter) {
      int position = (*iter).find_first_of(":");
      if (position != std::string::npos) {
        std::string hostname = (*iter).substr(0, position );
        int portnumber = atoi(((*iter).substr(position + 1)).c_str());
        if ( poolLocators ) {
          LOG((*iter));

          pfPtr->addLocator(hostname.c_str(), portnumber);
        }
        else {
          pfPtr->addServer(hostname.c_str(), portnumber);
        }
      }
    }
  }

  void CacheHelper::addServerLocatorEPs( const char* epList, CacheFactoryPtr cacheFac, bool poolLocators )
    {
      std::unordered_set<std::string> endpointNames;
      Utils::parseEndpointNamesString(epList, endpointNames);
      for (std::unordered_set<std::string>::iterator iter = endpointNames.begin(); iter
          != endpointNames.end(); ++iter) {
        int position = (*iter).find_first_of(":");
        if (position != std::string::npos) {
          std::string hostname = (*iter).substr(0, position );
          int portnumber = atoi(((*iter).substr(position + 1)).c_str());
          if ( poolLocators ) {
            cacheFac->addLocator(hostname.c_str(), portnumber);
          }
          else {
            printf("ankur Server: %d", portnumber);
            cacheFac->addServer(hostname.c_str(), portnumber);
          }
        }
      }
    }

  RegionPtr CacheHelper::createPooledRegion(const char* name, bool ack, const char* endpoints,
                               const char* locators, const char* poolName,
                               bool caching , bool clientNotificationEnabled ,
                               int ettl, int eit, int rttl, int rit,int lel ,
                               const CacheListenerPtr& cacheListener,
                               ExpirationAction::Action action  )
  {
    PoolFactoryPtr poolFacPtr = PoolManager::createFactory();
    poolFacPtr->setSubscriptionEnabled( clientNotificationEnabled );

    if( endpoints != 0 )//with endpoints
    {
      LOG("adding pool servers");
      addServerLocatorEPs( endpoints, poolFacPtr, false );
      //do region creation with end
    }
    else if(locators != 0) //with locator
    {
      LOG("adding pool locators");
      addServerLocatorEPs( locators, poolFacPtr );
    }
    else //neither server nor locator return NULLPTR
    {
      LOG("returning null region ptr");
      return RegionPtr( NULLPTR);
    }
    if((PoolManager::find( poolName ))== NULLPTR ) {// Pool does not exist with the same name.
      PoolPtr pptr = poolFacPtr->create(poolName);
    }

    RegionShortcut preDefRA = PROXY;
    if (caching) {
      preDefRA = CACHING_PROXY;
    }
    if (lel > 0) {
      preDefRA = CACHING_PROXY_ENTRY_LRU;
    }
    RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
    regionFactoryPtr->setLruEntriesLimit(lel);
    regionFactoryPtr->setEntryIdleTimeout(action, eit);
    regionFactoryPtr->setEntryTimeToLive(action, ettl);
    regionFactoryPtr->setRegionIdleTimeout(action, rit);
    regionFactoryPtr->setRegionTimeToLive(action, rttl);	
    regionFactoryPtr->setPoolName(poolName);
    if( cacheListener != NULLPTR ) {
      regionFactoryPtr->setCacheListener( cacheListener );
    }    
    return regionFactoryPtr->create(name);
  }

  RegionPtr CacheHelper::createPooledRegionConcurrencyCheckDisabled(const char* name, bool ack, const char* endpoints ,
    const char* locators , const char* poolName ,
    bool caching , bool clientNotificationEnabled, bool concurrencyCheckEnabled,
    int ettl , int eit, int rttl , int rit ,int lel ,
    const CacheListenerPtr& cacheListener,
    ExpirationAction::Action action   )
  {
    PoolFactoryPtr poolFacPtr = PoolManager::createFactory();
    poolFacPtr->setSubscriptionEnabled( clientNotificationEnabled );

    if( endpoints != 0 )//with endpoints
    {
      LOG("adding pool servers");
      addServerLocatorEPs( endpoints, poolFacPtr, false );
      //do region creation with end
    }
    else if(locators != 0) //with locator
    {
      LOG("adding pool locators");
      addServerLocatorEPs( locators, poolFacPtr );
    }
    else //neither server nor locator return NULLPTR
    {
      LOG("returning null region ptr");
      return RegionPtr( NULLPTR);
    }
    if((PoolManager::find( poolName ))== NULLPTR ) {// Pool does not exist with the same name.
      PoolPtr pptr = poolFacPtr->create(poolName);
    }

    RegionShortcut preDefRA = PROXY;
    if (caching) {
      preDefRA = CACHING_PROXY;
    }
    if (lel > 0) {
      preDefRA = CACHING_PROXY_ENTRY_LRU;
    }
    RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
    regionFactoryPtr->setLruEntriesLimit(lel);
    regionFactoryPtr->setEntryIdleTimeout(action, eit);
    regionFactoryPtr->setEntryTimeToLive(action, ettl);
    regionFactoryPtr->setRegionIdleTimeout(action, rit);
    regionFactoryPtr->setRegionTimeToLive(action, rttl);
    regionFactoryPtr->setConcurrencyChecksEnabled(concurrencyCheckEnabled);
    regionFactoryPtr->setPoolName(poolName);
    if( cacheListener != NULLPTR ) {
      regionFactoryPtr->setCacheListener( cacheListener );
    }    
    return regionFactoryPtr->create(name);
  }

  RegionPtr CacheHelper::createRegionDiscOverFlow(const char* name, bool caching, bool clientNotificationEnabled,
                               int ettl , int eit , int rttl, int rit ,int lel ,
                               ExpirationAction::Action action  )
  {
    AttributesFactory af;
    af.setScope( ScopeType::DISTRIBUTED_ACK );
    af.setCachingEnabled( caching );
    af.setLruEntriesLimit(lel);
    af.setEntryIdleTimeout(action, eit);
    af.setEntryTimeToLive(action, ettl);
    af.setRegionIdleTimeout(action, rit);
    af.setRegionTimeToLive(action, rttl);
    af.setCloningEnabled( true );
    af.setClientNotificationEnabled( true );
    if( lel > 0 ){
    af.setDiskPolicy(DiskPolicyType::OVERFLOWS);
    PropertiesPtr sqLiteProps = Properties::create();
    sqLiteProps->insert("PageSize","65536");
    sqLiteProps->insert("MaxPageCount","1073741823");
    std::string sqlite_dir = "SqLiteRegionData";
    sqLiteProps->insert("PersistenceDirectory", sqlite_dir.c_str());
    af.setPersistenceManager("SqLiteImpl","createSqLiteInstance",sqLiteProps);
    }

    RegionAttributesPtr rattrsPtr = af.createRegionAttributes( );
    return cachePtr->createRegion( name, rattrsPtr );
  }


  RegionPtr CacheHelper::createPooledRegionDiscOverFlow(const char* name, bool ack, const char* endpoints,
                               const char* locators , const char* poolName,
                               bool caching , bool clientNotificationEnabled,
                               int ettl , int eit , int rttl , int rit ,int lel,
                               const CacheListenerPtr& cacheListener,
                               ExpirationAction::Action action )
  {
    PoolFactoryPtr poolFacPtr = PoolManager::createFactory();
    poolFacPtr->setSubscriptionEnabled( clientNotificationEnabled );

    if( endpoints != 0 )//with endpoints
    {
      LOG("adding pool servers");
      addServerLocatorEPs( endpoints, poolFacPtr, false );
      //do region creation with end
    }
    else if(locators != 0) //with locator
    {
      LOG("adding pool locators");
      addServerLocatorEPs( locators, poolFacPtr );
    }
    else //neither server nor locator return NULLPTR
    {
      LOG("returning null region ptr");
      return RegionPtr( NULLPTR);
    }
    if((PoolManager::find( poolName ))== NULLPTR ) {// Pool does not exist with the same name.
      PoolPtr pptr = poolFacPtr->create(poolName);
    }
    
    if (!caching) {
      LOG("createPooledRegionDiscOverFlow: setting caching=false does not make sense");
      FAIL("createPooledRegionDiscOverFlow: setting caching=false does not make sense");
    }
    RegionShortcut preDefRA = CACHING_PROXY;
    if (lel > 0) {
      preDefRA = CACHING_PROXY_ENTRY_LRU;
    }
    RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
    regionFactoryPtr->setLruEntriesLimit(lel);
    regionFactoryPtr->setEntryIdleTimeout(action, eit);
    regionFactoryPtr->setEntryTimeToLive(action, ettl);
    regionFactoryPtr->setRegionIdleTimeout(action, rit);
    regionFactoryPtr->setRegionTimeToLive(action, rttl);
    regionFactoryPtr->setPoolName(poolName);
    regionFactoryPtr->setCloningEnabled(true);
    if (lel > 0) {
      regionFactoryPtr->setDiskPolicy(DiskPolicyType::OVERFLOWS);
      PropertiesPtr sqLiteProps = Properties::create();
      sqLiteProps->insert("PageSize","65536");
      sqLiteProps->insert("MaxPageCount","1073741823");
      std::string sqlite_dir = "SqLiteRegionData";
      sqLiteProps->insert("PersistenceDirectory", sqlite_dir.c_str());
      regionFactoryPtr->setPersistenceManager("SqLiteImpl","createSqLiteInstance",sqLiteProps);
    }    
    if( cacheListener != NULLPTR ) {
      regionFactoryPtr->setCacheListener( cacheListener );
    }    
    return regionFactoryPtr->create(name);
  }


  RegionPtr CacheHelper::createPooledRegionSticky(const char* name, bool ack, const char* endpoints,
                               const char* locators , const char* poolName,
                               bool caching, bool clientNotificationEnabled ,
                               int ettl, int eit, int rttl, int rit,int lel,
                               const CacheListenerPtr& cacheListener,
                               ExpirationAction::Action action)
  {
    PoolFactoryPtr poolFacPtr = PoolManager::createFactory();
    poolFacPtr->setSubscriptionEnabled( clientNotificationEnabled );
    poolFacPtr->setThreadLocalConnections( true );
    poolFacPtr->setPRSingleHopEnabled( false );
    if( endpoints != 0 )//with endpoints
    {
      LOG("adding pool servers");
      addServerLocatorEPs( endpoints, poolFacPtr, false );
      //do region creation with end
    }
    else if(locators != 0) //with locator
    {
      LOG("adding pool locators");
      addServerLocatorEPs( locators, poolFacPtr );
    }
    else //neither server nor locator return NULLPTR
    {
      LOG("returning null region ptr");
      return RegionPtr( NULLPTR);
    }
    if((PoolManager::find( poolName ))== NULLPTR ) {// Pool does not exist with the same name.
      PoolPtr pptr = poolFacPtr->create(poolName);
      LOG("createPooledRegionSticky logPoolAttributes");
      logPoolAttributes(pptr);
    }

    RegionShortcut preDefRA = PROXY;
    if (caching) {
      preDefRA = CACHING_PROXY;
    }
    if (lel > 0) {
      preDefRA = CACHING_PROXY_ENTRY_LRU;
    }
    RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
    regionFactoryPtr->setLruEntriesLimit(lel);
    regionFactoryPtr->setEntryIdleTimeout(action, eit);
    regionFactoryPtr->setEntryTimeToLive(action, ettl);
    regionFactoryPtr->setRegionIdleTimeout(action, rit);
    regionFactoryPtr->setRegionTimeToLive(action, rttl);
    regionFactoryPtr->setPoolName(poolName);
    if( cacheListener != NULLPTR ) {
      regionFactoryPtr->setCacheListener( cacheListener );
    }    
    return regionFactoryPtr->create(name);
  }

  RegionPtr CacheHelper::createPooledRegionStickySingleHop(const char* name, bool ack, const char* endpoints,
                               const char* locators, const char* poolName,
                               bool caching, bool clientNotificationEnabled,
                               int ettl, int eit , int rttl , int rit ,int lel,
                               const CacheListenerPtr& cacheListener,
                               ExpirationAction::Action action )
  {
    LOG("createPooledRegionStickySingleHop");
    PoolFactoryPtr poolFacPtr = PoolManager::createFactory();
    poolFacPtr->setSubscriptionEnabled( clientNotificationEnabled );
    poolFacPtr->setThreadLocalConnections( true );
    poolFacPtr->setPRSingleHopEnabled( true );
    if( endpoints != 0 )//with endpoints
    {
      LOG("adding pool servers");
      addServerLocatorEPs( endpoints, poolFacPtr, false );
      //do region creation with end
    }
    else if(locators != 0) //with locator
    {
      LOG("adding pool locators");
      addServerLocatorEPs( locators, poolFacPtr );
    }
    else //neither server nor locator return NULLPTR
    {
      LOG("returning null region ptr");
      return RegionPtr( NULLPTR);
    }
    if((PoolManager::find( poolName ))== NULLPTR ) {// Pool does not exist with the same name.
      PoolPtr pptr = poolFacPtr->create(poolName);
      LOG("createPooledRegionStickySingleHop logPoolAttributes");
      logPoolAttributes(pptr);
    }

    RegionShortcut preDefRA = PROXY;
    if (caching) {
      preDefRA = CACHING_PROXY;
    }
    if (lel > 0) {
      preDefRA = CACHING_PROXY_ENTRY_LRU;
    }
    RegionFactoryPtr regionFactoryPtr = cachePtr->createRegionFactory(preDefRA);
    regionFactoryPtr->setLruEntriesLimit(lel);
    regionFactoryPtr->setEntryIdleTimeout(action, eit);
    regionFactoryPtr->setEntryTimeToLive(action, ettl);
    regionFactoryPtr->setRegionIdleTimeout(action, rit);
    regionFactoryPtr->setRegionTimeToLive(action, rttl);
    regionFactoryPtr->setPoolName(poolName);
    if( cacheListener != NULLPTR ) {
      regionFactoryPtr->setCacheListener( cacheListener );
    }    
    return regionFactoryPtr->create(name);
  }

  RegionPtr CacheHelper::createSubregion(RegionPtr& parent, const char* name, bool ack, bool caching, const CacheListenerPtr& listener )
  {
    AttributesFactory af;
    af.setScope( ack ? ScopeType::DISTRIBUTED_ACK : ScopeType::DISTRIBUTED_NO_ACK );
    af.setCachingEnabled( caching );
    if ( listener != NULLPTR ) {
      af.setCacheListener( listener );
    }
    RegionAttributesPtr rattrsPtr = af.createRegionAttributes( );

    return parent->createSubregion( name, rattrsPtr );
  }


  CacheableStringPtr CacheHelper::createCacheable( const char* value ) {
    return CacheableString::create( value );
  }

  void CacheHelper::showKeys( VectorOfCacheableKey& vecKeys )
  {
      fprintf( stdout, "vecKeys.size() = %d\n", vecKeys.size() );
      for( uint32_t i = 0; i < (uint32_t)vecKeys.size(); i++ ) {
        char msg[1024];
        size_t wrote = vecKeys.at(i)->logString( msg, 1023 );
        msg[wrote] = '\0'; // just in case...
        fprintf( stdout, "key[%d] - %s\n", i, msg );
      }
      fflush( stdout );
  }

  void CacheHelper::showRegionAttributes( RegionAttributes& attributes )
  {
    printf("caching=%s\n", attributes.getCachingEnabled()? "true": "false");
    printf("scope=%s\n", ScopeType::fromOrdinal(attributes.getScope()));
    printf("Entry Time To Live = %d\n", attributes.getEntryTimeToLive());
    printf("Entry Idle Timeout = %d\n", attributes.getEntryIdleTimeout());
    printf("Region Time To Live = %d\n", attributes.getRegionTimeToLive());
    printf("Region Idle Timeout = %d\n", attributes.getRegionIdleTimeout());
    printf("Initial Capacity = %d\n", attributes.getInitialCapacity());
    printf("Load Factor = %f\n", attributes.getLoadFactor());
    printf("End Points = %s\n", (attributes.getEndpoints() != NULL ?
        attributes.getEndpoints() : "(null)"));
  }

  QueryServicePtr CacheHelper::getQueryService( )
  {
    return cachePtr->getQueryService( );
  }


   const char * CacheHelper::getTcrEndpoints( bool & isLocalServer, int numberOfServers )
  {
    static char * gfjavaenv = ACE_OS::getenv( "GFJAVA" );
    std::string gfendpoints;
    static bool gflocalserver = false;
    char tmp[100];

    if ( gfendpoints.empty() ) {
      if ( ( ACE_OS::strchr( gfjavaenv,'\\') != NULL ) || ( ACE_OS::strchr( gfjavaenv,'/') != NULL ) ) {
        gflocalserver = true;
        /* Support for multiple servers Max = 10*/
        switch( numberOfServers ) {
          case 1:
            //gfendpoints = "localhost:24680";
            {
              gfendpoints = "localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort1 );
              gfendpoints += tmp;
            }
            break;
          case 2:
            //gfendpoints = "localhost:24680,localhost:24681";
            {
              gfendpoints = "localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort1 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort2 );
              gfendpoints += tmp;
            }
            break;
          case 3:
             //gfendpoints = "localhost:24680,localhost:24681,localhost:24682";
             {
              gfendpoints = "localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort1 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort2 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort3 );
              gfendpoints += tmp;
            }
             break;
          default:
             //ASSERT( ( numberOfServers <= 10 )," More than 10 servers not supported");
             //TODO: need to support more servers, need to generate random ports here
             ASSERT( ( numberOfServers <= 4 )," More than 4 servers not supported");
             gfendpoints = "localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort1 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort2 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort3 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort4 );
              gfendpoints += tmp;
             /*gfendpoints = "localhost:24680";
             char temp[8];
             for(int i =1; i <= numberOfServers - 1; i++) {
              gfendpoints += ",localhost:2468";
              gfendpoints += ACE_OS::itoa(i,temp,10);
             }*/
             break;
        }
      }
      else {
        gfendpoints = gfjavaenv;
      }
    }
    ASSERT( gfjavaenv != NULL, "Environment variable GFJAVA for java build directory is not set." );
    isLocalServer = gflocalserver;
    printf("getHostPort :: %s \n", gfendpoints.c_str( ));
    return ( new std::string( gfendpoints.c_str( ) ) )->c_str( );
  }

   const char * CacheHelper::getstaticLocatorHostPort1 () {
	return getLocatorHostPort(staticLocatorHostPort1);
  }
  
   const char * CacheHelper::getstaticLocatorHostPort2 () {
	return getLocatorHostPort(staticLocatorHostPort2);
  }

   const char * CacheHelper::getLocatorHostPort ( int locPort) {
	char tmp[128];
	std::string gfendpoints;
	gfendpoints = "localhost:";
	sprintf( tmp, "%d", locPort );
    gfendpoints += tmp;
	return ( new std::string( gfendpoints.c_str( ) ) )->c_str( );;
  }

   const char * CacheHelper::getTcrEndpoints2( bool & isLocalServer, int numberOfServers )
  {
    static char * gfjavaenv = ACE_OS::getenv( "GFJAVA" );
    std::string gfendpoints;
    static bool gflocalserver = false;
    char tmp[128];

    if ( gfendpoints.empty() ) {
      if ( ( ACE_OS::strchr( gfjavaenv,'\\') != NULL ) || ( ACE_OS::strchr( gfjavaenv,'/') != NULL ) ) {
        gflocalserver = true;
        /* Support for multiple servers Max = 10*/
        switch( numberOfServers ) {
          case 1:
            //gfendpoints = "localhost:24680";
            {
              gfendpoints = "localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort1 );
              gfendpoints += tmp;
            }
            break;
          case 2:
            //gfendpoints = "localhost:24680,localhost:24681";
             {
              gfendpoints = "localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort1 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort2 );
              gfendpoints += tmp;
            }
            break;
          case 3:
             //gfendpoints = "localhost:24680,localhost:24681,localhost:24682";
              {
              gfendpoints = "localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort1 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort2 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort3 );
              gfendpoints += tmp;
            }
             break;
          case 4:
             //gfendpoints = "localhost:24680,localhost:24681,localhost:24682,localhost:24683";
             {
              gfendpoints = "localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort1 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort2 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort3 );
              gfendpoints += tmp;
              gfendpoints += ",localhost:";
              sprintf( tmp, "%d", CacheHelper::staticHostPort4 );
              gfendpoints += tmp;
             }
             break;
          default:
             ASSERT( ( numberOfServers <= 10 )," More than 10 servers not supported");
             gfendpoints = "localhost:24680";
             char temp[8];
             for(int i =1; i <= numberOfServers - 1; i++) {
              gfendpoints += ",localhost:2468";
              gfendpoints += ACE_OS::itoa(i,temp,10);
             }
             break;
        }
      }
      else {
        gfendpoints = gfjavaenv;
      }
    }
    ASSERT( gfjavaenv != NULL, "Environment variable GFJAVA for java build directory is not set." );
    isLocalServer = gflocalserver;
    return ( new std::string( gfendpoints.c_str( ) ) )->c_str( );
  }

  const char * CacheHelper::getLocatorHostPort( bool & isLocator, int numberOfLocators)
  {
    static char * gfjavaenv = ACE_OS::getenv( "GFJAVA" );
    static std::string gflchostport;
    static bool gflocator = false;
    char tmp[100];

    if ( gflchostport.empty() ) {
      if ( ( ACE_OS::strchr( gfjavaenv,'\\') != NULL ) || ( ACE_OS::strchr( gfjavaenv,'/') != NULL ) ) {
        gflocator = true;
        switch( numberOfLocators ) {
          case 1:
            //gflchostport = "localhost:34756";
            {
              gflchostport = "localhost:";
              sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort1  );
              gflchostport += tmp;
            }
            break;
          case 2:
            //gflchostport = "localhost:34756,localhost:34757";
            {
              gflchostport = "localhost:";
              sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort1  );
              gflchostport += tmp;
              sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort2  );
              gflchostport += ",localhost:";
              gflchostport += tmp;
            }
            break;
          default:
             //gflchostport = "localhost:34756,localhost:34757,localhost:34758";
             {
              gflchostport = "localhost:";
              sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort1  );
              gflchostport += tmp;
              sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort2  );
              gflchostport += ",localhost:";
              gflchostport += tmp;
              sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort3  );
              gflchostport += ",localhost:";
              gflchostport += tmp;
            }
             break;
        }
      }
      else {
       gflchostport = "";
      }
    }
    ASSERT( gfjavaenv != NULL, "Environment variable GFJAVA for java build directory is not set." );
    isLocator = gflocator;
    printf("getLocatorHostPort Hitesh :: %s  \n", gflchostport.c_str());
    return gflchostport.c_str();
  }

  void CacheHelper::cleanupServerInstances()
  {
    CacheHelper::cleanupTmpConfigFiles();
    if( staticServerInstanceList.size() > 0 )
    {
      while( staticServerInstanceList.size() > 0 )
      {
        int instance = staticServerInstanceList.front();

        staticServerInstanceList.remove( instance ); // for safety
        closeServer( instance );
      }
    }
  }
  void CacheHelper::initServer( int instance, const char * xml ,const char *locHostport , const char *authParam , bool ssl,
     bool enableDelta  , bool multiDS, bool testServerGC) {
    if ( !isServerCleanupCallbackRegistered && gClientCleanup.registerCallback(&CacheHelper::cleanupServerInstances) ) {
      isServerCleanupCallbackRegistered = true;
      printf("TimeBomb registered server cleanupcallback \n");
    }
    printf("Inside initServer added\n");
    if (authParam != NULL) {
      printf("Inside initServer with authParam = %s\n", authParam);
    }
    else {
      printf("Inside initServer with authParam as NULL\n");
      authParam = "";
    }
    static const char* gfjavaenv = ACE_OS::getenv("GFJAVA");
    static const char* gfLogLevel = ACE_OS::getenv("GFE_LOGLEVEL");
    static const char* gfSecLogLevel = ACE_OS::getenv("GFE_SECLOGLEVEL");
    static const char* path = ACE_OS::getenv("TESTSRC");
    static const char* mcastPort = ACE_OS::getenv("MCAST_PORT");
    static const char* mcastAddr = ACE_OS::getenv("MCAST_ADDR");
	static char * classpath = ACE_OS::getenv( "GF_CLASSPATH" );

    char cmd[2048];
    char tmp[128];
    char currWDPath[2048];
    int portNum;
    std::string currDir = ACE_OS::getcwd( currWDPath, 2048 );

    ASSERT( gfjavaenv != NULL, "Environment variable GFJAVA for java build directory is not set." );
    ASSERT( path != NULL, "Environment variable TESTSRC for test source directory is not set." );
    ASSERT( mcastPort != NULL, "Environment variable MCAST_PORT for multicast port is not set." );
    ASSERT( mcastAddr != NULL, "Environment variable MCAST_ADDR for multicast address is not set." );
    ASSERT( !currDir.empty(), "Current working directory could not be determined." );
    if (gfLogLevel == NULL || gfLogLevel[0] == '\0') {
      gfLogLevel = "config";
    }
    if (gfSecLogLevel == NULL || gfSecLogLevel[0] == '\0') {
      gfSecLogLevel = "config";
    }

    if ( ( ACE_OS::strchr( gfjavaenv,'\\') == NULL ) && ( ACE_OS::strchr( gfjavaenv,'/') == NULL ) )
      return;

    std::string xmlFile = "";
    std::string sname = "GFECS";
    currDir += PATH_SEP;

    switch( instance ) {
      case 0:
      //note: this need to take for multiple tests run
        xmlFile += "cacheserver.xml";
        sname += "0";
        if( multiDS ) {
          mcastPort = "5431";
          mcastAddr = "224.10.11.";
        }
      break;
      case 1:
        xmlFile += "cacheserver.xml";
	sprintf( tmp, "%d", CacheHelper::staticHostPort1 );
        sname += tmp; //sname += "1";
        portNum = CacheHelper::staticHostPort1;

        if( multiDS ) {
          mcastPort = "5431";
          mcastAddr = "224.10.11.";
        }
      break;
      case 2:
        xmlFile += "cacheserver2.xml";
		sprintf( tmp, "%d", CacheHelper::staticHostPort2 );
        sname += tmp; //sname += "3";
        portNum = CacheHelper::staticHostPort2;
        //sname += "2";
        if( multiDS ) {
          mcastPort = "5431";
          mcastAddr = "224.10.11.";
        }
      break;
      case 3:
        xmlFile += "cacheserver3.xml";
		sprintf( tmp, "%d", CacheHelper::staticHostPort3 );
        sname += tmp; //sname += "3";
        portNum = CacheHelper::staticHostPort3;
        //sname += "3";
        if( multiDS ) {
          mcastPort = "5433";
          mcastAddr = "224.10.11.";
        }
      break;
      case 4:
        xmlFile += "cacheserver4.xml";
        //sname += "4"; 
        sprintf( tmp, "%d", CacheHelper::staticHostPort4 );
        sname += tmp; //sname += "3";
        portNum = CacheHelper::staticHostPort4;
        if( multiDS ) {
          mcastPort = "5433";
          mcastAddr = "224.10.11.";
        }
      break;
      default:  /* Support for any number of servers Max 10*/
        ASSERT( ( instance <= 10 )," More than 10 servers not supported");
        ASSERT( xml != NULL, "xml == NULL : For server instance > 3 xml file is must");
        char temp[8];
        portNum = CacheHelper::staticHostPort4;
        sname += ACE_OS::itoa(CacheHelper::staticHostPort4,temp,10);
      break;
    }

    currDir += sname;

    if ( xml != NULL ) {
      /*
      xmlFile = path;
      xmlFile += PATH_SEP;
      xmlFile += xml;
      */
      xmlFile = xml;
    }

    std::string xmlFile_new;
    printf("hitesh xml file name = %s \n",xmlFile.c_str());
    CacheHelper::createDuplicateXMLFile( xmlFile_new, xmlFile);
   // sprintf( tmp, "%d.xml", portNum );
   // xmlFile += tmp;
    xmlFile = xmlFile_new;
  
    printf("hitesh  creating dir = %s \n", sname.c_str());
    ACE_OS::mkdir( sname.c_str() );

//    sprintf( cmd, "/bin/cp %s/../test.gemfire.properties %s/",currDir.c_str(),
  //currDir.c_str()  );
    //LOG( cmd );
    //ACE_OS::system( cmd );

    sprintf(cmd, "%s/bin/%s stop server --dir=%s", gfjavaenv, GFSH,
        currDir.c_str());

    LOG( cmd );
    ACE_OS::system( cmd );
    std::string deltaProperty = "";
    if ( !enableDelta ) {
      deltaProperty = "delta-propagation=false";
    }
    long defaultTombstone_timeout = 600000;
    long defaultTombstone_gc_threshold = 100000;
    long userTombstone_timeout = 1000;
    long userTombstone_gc_threshold = 10;
    if(testServerGC){
      ACE_OS::mkdir( "backupDirectory1" );
      ACE_OS::mkdir( "backupDirectory2" );
      ACE_OS::mkdir( "backupDirectory3" );
      ACE_OS::mkdir( "backupDirectory4" );
    }

    if (locHostport != NULL) { // check number of locator host port.
        std::string gemfireProperties = generateGemfireProperties(currDir, ssl);

      if (ssl) {
        sprintf(cmd, "%s/bin/%s start server --classpath=%s --name=%s --J=-Xmx1024m --J=-Xms128m "
            "--cache-xml-file=%s --dir=%s --log-level=%s "
            "--properties-file=%s "
            "--J=-Dgemfire.tombstone-timeout=%ld --J=-Dgemfire.tombstone-gc-hreshold=%ld "
            "--J=-Dgemfire.security-log-level=%s %s %s",
            gfjavaenv, GFSH, classpath, sname.c_str(),
            xmlFile.c_str(), currDir.c_str(), gfLogLevel,
            gemfireProperties.c_str(),
            testServerGC ? userTombstone_timeout : defaultTombstone_timeout, testServerGC ? userTombstone_gc_threshold : defaultTombstone_gc_threshold,
            gfSecLogLevel, authParam, deltaProperty.c_str());
      } else {
        sprintf(cmd, "%s/bin/%s start server --classpath=%s --name=%s --J=-Xmx1024m --J=-Xms128m  --J=-Dgemfire.tombstone-timeout=%ld --J=-Dgemfire.tombstone-gc-threshold=%ld "
            "--cache-xml-file=%s --dir=%s --mcast-port=0 --log-level=%s  --statistic-archive-file=statArchive.gfs "
            "--properties-file=%s "
            "--J=-Dgemfire.security-log-level=%s %s %s", gfjavaenv, GFSH, classpath, sname.c_str(),
            testServerGC ? userTombstone_timeout : defaultTombstone_timeout, testServerGC ? userTombstone_gc_threshold : defaultTombstone_gc_threshold, xmlFile.c_str(), currDir.c_str(), gfLogLevel,
            gemfireProperties.c_str(),
            gfSecLogLevel, authParam, deltaProperty.c_str());
      }
    }
    else {
      sprintf(cmd, "%s/bin/%s start server --classpath=%s --name=%s --J=-Xmx1024m --J=-Xms128m --cache-xml-file=%s --J=-Dgemfire.tombstone-timeout=%ld --J=-Dgemfire.tombstone-gc-threshold=%ld "
          "--dir=%s --mcast-address=224.10.11.%d --mcast-port=%d --log-level=%s "
          "--J=-Dgemfire.security-log-level=%s %s %s", gfjavaenv, GFSH, classpath, sname.c_str(),
          xmlFile.c_str(), testServerGC ? userTombstone_timeout : defaultTombstone_timeout, testServerGC ? userTombstone_gc_threshold : defaultTombstone_gc_threshold, currDir.c_str(), staticMcastAddress, staticMcastPort, gfLogLevel,
          gfSecLogLevel, authParam, deltaProperty.c_str());
    }

    LOG( cmd );
    int e = ACE_OS::system( cmd );
    ASSERT( 0 == e, "cmd failed" );

    staticServerInstanceList.push_back( instance );
    printf("added server instance %d\n", instance);
}

 void CacheHelper::createDuplicateXMLFile(std::string& originalFile, int hostport1, int hostport2,  int locport1, int locport2)
{
  char cmd[1024];
  char currWDPath[2048];
  std::string currDir = ACE_OS::getcwd( currWDPath, 2048 );
  currDir += PATH_SEP;
  std::string testSrc = ACE_OS::getenv("TESTSRC");
  testSrc += PATH_SEP;
  //file name will have hostport1.xml(i.e. CacheHelper::staticHostPort1) as suffix
  sprintf( cmd, "sed -e s/HOST_PORT1/%d/g -e s/HOST_PORT2/%d/g -e s/HOST_PORT3/%d/g -e s/HOST_PORT4/%d/g -e s/LOC_PORT1/%d/g -e s/LOC_PORT2/%d/g <%s%s> %s%s%d.xml",
              hostport1, hostport2, CacheHelper::staticHostPort3, CacheHelper::staticHostPort4, locport1, locport2, testSrc.c_str(),
              originalFile.c_str(), currDir.c_str(), originalFile.c_str(), hostport1 );

  LOG( cmd );
  int e = ACE_OS::system( cmd );
  ASSERT( 0 == e, "cmd failed" );

  //this file need to delete
  sprintf( cmd, "%s%s%d.xml", currDir.c_str(), originalFile.c_str(), hostport1);
  std::string s(cmd);
  CacheHelper::staticConfigFileList.push_back(s);
  
  printf( "createDuplicateXMLFile added file %s %ld", cmd, CacheHelper::staticConfigFileList.size());
}

 void CacheHelper::createDuplicateXMLFile(std::string& duplicateFile, std::string& originalFile)
{
  CacheHelper::createDuplicateXMLFile( originalFile, CacheHelper::staticHostPort1, CacheHelper::staticHostPort2, CacheHelper::staticLocatorHostPort1, CacheHelper::staticLocatorHostPort2 );
  
  char tmp[32];
  
  sprintf( tmp, "%d.xml", CacheHelper::staticHostPort1);
  
  char currWDPath[2048];
  duplicateFile = ACE_OS::getcwd( currWDPath, 2048 );
  duplicateFile += PATH_SEP;  
  duplicateFile += originalFile + tmp;
}


 void  CacheHelper::initGFMOnAgent(int instance, const char* rmiPort)
{
  static char * gfjavaenv = ACE_OS::getenv( "GFJAVA" );
  //static char * path = ACE_OS::getenv( "TESTSRC" );
  static char* mcastPort = ACE_OS::getenv( "MCAST_PORT" );
  static char * mcastAddr = ACE_OS::getenv( "MCAST_ADDR" );
  char cmd[2048];
  char currWDPath[2048];
  std::string currDir = ACE_OS::getcwd( currWDPath, 2048 );
  char inst[3];
  LOG("Prashant");
  LOG(mcastPort);
  sprintf(inst,"%d",instance);
  currDir+=PATH_SEP;
  std::string sname = "GFECS";
  sname.append(inst);
  ACE_OS::mkdir( sname.c_str() );
  currDir+=sname;
  sprintf( cmd, "%s/bin/%s stop -dir=%s", gfjavaenv, "agent", currDir.c_str() );
  ACE_OS::system( cmd );
  bool isLocator = true;
  const char* locHostPort = getLocatorHostPort( isLocator );
  sprintf( cmd, "%s/bin/%s start rmi-port=%s mcast-address=224.10.11.%d mcast-port=0 locators=%s -dir=%s", gfjavaenv,"agent", rmiPort ,staticMcastAddress, locHostPort/*mcastPort*/, currDir.c_str() );
  LOG(cmd);
  ACE_OS::system( cmd );
}
void CacheHelper::closeGFMOnAgent(int instance)
{
   static char * gfjavaenv = ACE_OS::getenv( "GFJAVA" );
  //static char * path = ACE_OS::getenv( "TESTSRC" );

  char cmd[2048];
  char currWDPath[2048];
  std::string currDir = ACE_OS::getcwd( currWDPath, 2048 );
  char inst[3];
  sprintf(inst,"%d",instance);
  currDir+=PATH_SEP;
  std::string sname = "GFECS";
  sname.append(inst);
  ACE_OS::mkdir( sname.c_str() );
  currDir+=sname;

  ACE_OS::mkdir( sname.c_str() );
  sprintf( cmd, "%s/bin/%s stop -dir=%s", gfjavaenv, "agent", currDir.c_str() );
  LOG( cmd );
  ACE_OS::system( cmd );
}
  void CacheHelper::closeServer( int instance )
  {
    static char * gfjavaenv = ACE_OS::getenv( "GFJAVA" );

    char cmd[2048];
    char tmp[128];
    char currWDPath[2048];

    std::string currDir = ACE_OS::getcwd( currWDPath, 2048 );

    ASSERT( gfjavaenv != NULL, "Environment variable GFJAVA for java build directory is not set." );
    ASSERT( !currDir.empty(), "Current working directory could not be determined." );

    if ( ( ACE_OS::strchr( gfjavaenv,'\\') == NULL ) && ( ACE_OS::strchr( gfjavaenv,'/') == NULL ) )
      return;

    currDir += "/GFECS";
    switch( instance ) {
      case 0:
        currDir += "0";
        break;
      case 1:
        sprintf( tmp, "%d", CacheHelper::staticHostPort1 );
        currDir += tmp; //currDir += "1";
      break;
      case 2:
        sprintf( tmp, "%d", CacheHelper::staticHostPort2 );
        currDir += tmp; //currDir += "2";
      break;
      case 3:
        sprintf( tmp, "%d", CacheHelper::staticHostPort3 );
        currDir += tmp; //currDir += "3";
      break;
      default: /* Support for any number of servers Max 10*/
        //ASSERT( ( instance <= 10 )," More than 10 servers not supported");
        //TODO: need to support more then three servers
        ASSERT( ( instance <= 4 )," More than 4 servers not supported");
        char temp[8];
        currDir += ACE_OS::itoa(CacheHelper::staticHostPort4,temp,10);
      break;
    }

    sprintf(cmd, "%s/bin/%s stop server --dir=%s", gfjavaenv, GFSH,
        currDir.c_str());

    LOG( cmd );
    ACE_OS::system( cmd );

    staticServerInstanceList.remove( instance );    
  }
  // closing locator
   void CacheHelper::closeLocator( int instance, bool ssl )
  {
    static char * gfjavaenv = ACE_OS::getenv( "GFJAVA" );

    char cmd[2048];
    char currWDPath[2048];
    int portnum = 0;
    std::string currDir = ACE_OS::getcwd( currWDPath, 2048 );
    std::string keystore = std::string(ACE_OS::getenv("TESTSRC")) + "/keystore";

    ASSERT( gfjavaenv != NULL, "Environment variable GFJAVA for java build directory is not set." );
    ASSERT( !currDir.empty(), "Current working directory could not be determined." );
    if ( ( ACE_OS::strchr( gfjavaenv,'\\') == NULL ) && ( ACE_OS::strchr( gfjavaenv,'/') == NULL ) )
      return;

    currDir += PATH_SEP;
    currDir += "GFELOC";
	char tmp[100];

    switch( instance ) {
      case 1:
        //portnum = 34756;
        portnum = CacheHelper::staticLocatorHostPort1;
        sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort1 );
        currDir += tmp; //currDir += "1";
      break;
      case 2:
        //portnum = 34757;
        portnum = CacheHelper::staticLocatorHostPort2;
        sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort2 );
        currDir += tmp;
        //currDir += "2";
      break;
      case 3:
        //portnum = 34758;
        portnum = CacheHelper::staticLocatorHostPort3;
        sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort3 );
        currDir += tmp;
        //currDir += "3";
      break;
      default: /* Support for any number of Locator Max 10*/
        //TODO://
        ASSERT( ( instance <= 3 )," More than 3 servers not supported");
        char temp[8];
        currDir += ACE_OS::itoa(instance,temp,10);
      break;
    }

    sprintf( cmd, "%s/bin/%s stop locator --dir=%s", gfjavaenv, GFSH, currDir.c_str() );
    LOG( cmd );
    ACE_OS::system( cmd );
    
    sprintf(cmd, "%s .%stest.gemfire.properties", DELETE_COMMAND, PATH_SEP);
    LOG( cmd );
    ACE_OS::system( cmd );
    
   staticLocatorInstanceList.remove( instance );
  }

  void CacheHelper::cleanupTmpConfigFiles()
  {
    std::list<std::string>::const_iterator its;
    
    char cmd[1024];
    for( its = CacheHelper::staticConfigFileList.begin(); its != CacheHelper::staticConfigFileList.end(); ++its)
    {
      try
      {
        sprintf( cmd, "rm %s", its->c_str());
        LOG(cmd);
        ACE_OS::system( cmd );
      }catch( ... )
      {
      }
    }    
  }

  void CacheHelper::cleanupLocatorInstances()
  {
    CacheHelper::cleanupTmpConfigFiles();
   if( staticLocatorInstanceList.size() > 0 )
    {
      while( staticLocatorInstanceList.size() > 0 )
      {
        int instance = staticLocatorInstanceList.front();

        staticLocatorInstanceList.remove( instance ); // for safety
        closeLocator( instance ); // this will also remove
      }
    }
  }

  // starting locator
   void CacheHelper::initLocator( int instance, bool ssl , bool multiDS , int dsId , int  remoteLocator ) {
    if ( !isLocatorCleanupCallbackRegistered && gClientCleanup.registerCallback(&CacheHelper::cleanupLocatorInstances) ) {
      isLocatorCleanupCallbackRegistered = true;
    }
    static char * gfjavaenv = ACE_OS::getenv( "GFJAVA" );

    char cmd[2048];
    char currWDPath[2048];
    std::string currDir = ACE_OS::getcwd( currWDPath, 2048 );
//    std::string keystore = std::string(ACE_OS::getenv("TESTSRC")) + "/keystore";

    ASSERT( gfjavaenv != NULL, "Environment variable GFJAVA for java build directory is not set." );
    ASSERT( !currDir.empty(), "Current working directory could not be determined." );

    if ( ( ACE_OS::strchr( gfjavaenv,'\\') == NULL ) && ( ACE_OS::strchr( gfjavaenv,'/') == NULL ) )
      return;
    std::string locDirname = "GFELOC";
    int portnum = 0;
    currDir += PATH_SEP;
	  char tmp [100];
    switch( instance ) {
      case 1:
        //portnum = 34756;
        portnum = CacheHelper::staticLocatorHostPort1;
        sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort1 );
        locDirname += tmp;
        //locDirname += "1";
      break;
      case 2:
        //portnum = 34757;
        portnum = CacheHelper::staticLocatorHostPort2;
        sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort2 );
        locDirname += tmp;
        //locDirname += "2";
      break;
      default:
        //portnum = 34758;
        portnum = CacheHelper::staticLocatorHostPort3;
        sprintf( tmp, "%d", CacheHelper::staticLocatorHostPort3 );
        locDirname += tmp;
        //locDirname += "3";
      break;
    }

    currDir += locDirname;

    ACE_OS::mkdir( locDirname.c_str() );

    std::string gemfireFile = generateGemfireProperties(currDir, ssl, dsId, remoteLocator);

    sprintf( cmd, "%s/bin/%s stop locator --dir=%s --properties-file=%s ",
        gfjavaenv, GFSH, currDir.c_str(), gemfireFile.c_str());

    LOG( cmd );
    ACE_OS::system( cmd );

    sprintf(cmd, "%s/bin/%s start locator --name=%s --port=%d --dir=%s --properties-file=%s ",
        gfjavaenv, GFSH, locDirname.c_str(), portnum, currDir.c_str(), gemfireFile.c_str());


    LOG( cmd );
    ACE_OS::system( cmd );
    staticLocatorInstanceList.push_back( instance );
  }

   void CacheHelper::clearSecProp()
  {
    PropertiesPtr tmpSecProp = DistributedSystem::getSystemProperties()->getSecurityProperties();
    tmpSecProp->remove("security-username");
    tmpSecProp->remove("security-password");
  }
   void CacheHelper::setJavaConnectionPoolSize(long size)
  {
    DistributedSystem::getSystemProperties()->setjavaConnectionPoolSize(size);
  }

   bool CacheHelper::setSeed()
  {
    //ACE_OS::sleep( 1 );
   // ACE_Time_Value now = ACE_OS::gettimeofday ();
   // ACE_OS::srand( now.msec() );

   /*char* mcastPort = ACE_OS::getenv("MCAST_PORT");
   int seed = 0;

   if( mcastPort != NULL )
   {
      seed = ACE_OS::atoi(mcastPort);
   }*/
      
    char * testName = ACE_OS::getenv( "TESTNAME" );
    
    int seed = hashcode(testName);
   
    printf( "seed for process %d\n", seed);
    ACE_OS::srand( seed );
    //ACE_OS::srand( 0 );
    return true;
  }

   int CacheHelper::hashcode(char * str)
  {
    if (str == NULL) {
      return 0;
    }
    int localHash = 0;

    int prime = 31;
    char *data = str;
    for (int i = 0; i < 50 && (data[i] != '\0') ; i++) {
      localHash = prime*localHash + data[i];
    } 
    if(localHash > 0)  
      return localHash;
    return -1 * localHash;
  }

   int CacheHelper::getRandomNumber()
  {
    //char * testName = ACE_OS::getenv( "TESTNAME" );
    
    //int seed = hashcode(testName);
    return (ACE_OS::rand() % RANDOM_NUMBER_DIVIDER ) + RANDOM_NUMBER_OFFSET;
  }
  
   int CacheHelper::getRandomAvailablePort()
  {
    while (true) {
      int port = CacheHelper::getRandomNumber();
      ACE_INET_Addr addr(port, "localhost");
      ACE_SOCK_Acceptor acceptor;
      int result = acceptor.open(addr, 0, AF_INET);
      if (result == -1) {
        continue;
      } else {
        result = acceptor.close();
        if (result == -1) {
          continue;
        } else {
          return port;
        }
      }
    }
  }

   PoolPtr CacheHelper::getPoolPtr(const char* poolName)
  {
      return PoolManager::find(poolName);
  }

   std::string CacheHelper::unitTestOutputFile()
  {
    char currWDPath[512];
    char *wdPath = ACE_OS::getcwd(currWDPath,512);

    char * testName = ACE_OS::getenv( "TESTNAME" );
	strcat(currWDPath, "/../");
	strcat(currWDPath, testName);
	strcat(currWDPath, ".out");

	std::string str(currWDPath);
	return str;
  }

   int CacheHelper::getNumLocatorListUpdates(const char* s)
  {
	  std::string searchStr(s);
    std::string testFile = CacheHelper::unitTestOutputFile();
	  FILE *fp = fopen(testFile.c_str(), "r");
	  char buf[512];
	  int numMatched = 0;
	  while (fgets(buf, sizeof(buf), fp))
	  {
		  std::string line(buf);
		  if (line.find(searchStr) != std::string::npos)
			  numMatched++;
	  }
	  return numMatched;
  }
  
   std::string CacheHelper::generateGemfireProperties(const std::string& path, const bool ssl, const int dsId , const int remoteLocator)
  {
    char cmd[2048];
    std::string keystore = std::string(ACE_OS::getenv("TESTSRC")) + "/keystore";

    std::string gemfireFile = path;
    gemfireFile += "/test.gemfire.properties";
    sprintf(cmd, "%s %s%stest.gemfire.properties", DELETE_COMMAND, path.c_str(), PATH_SEP);
    LOG( cmd );
    ACE_OS::system(cmd);
    FILE* urandom = /*ACE_OS::*/
    fopen(gemfireFile.c_str(), "w");
    char gemStr[258];
    sprintf(gemStr, "log-level=all\nlocators=localhost[%d],localhost[%d],localhost[%d]\n", CacheHelper::staticLocatorHostPort1, CacheHelper::staticLocatorHostPort2, CacheHelper::staticLocatorHostPort3);
    std::string msg = gemStr;
    if (ssl) {
      msg += "mcast-port=0\n";
      msg += "ssl-enabled=true\n";
      msg += "ssl-require-authentication=true\n";
      msg += "ssl-ciphers=SSL_RSA_WITH_NULL_MD5\n";
      msg += "jmx-manager-ssl-enabled=false\n";
      msg += "cluster-ssl-keystore-type=jks\n";
      msg += "cluster-ssl-keystore=" + keystore + "/server_keystore.jks\n";
      msg += "cluster-ssl-keystore-password=gemstone\n";
      msg += "cluster-ssl-truststore=" + keystore + "/server_truststore.jks\n";
      msg += "cluster-ssl-truststore-password=gemstone\n";
      msg += "security-username=xxxx\n";
      msg += "security-userPassword=yyyy \n";
    } else {
      if(remoteLocator != 0) {
        sprintf(gemStr,"distributed-system-id=%d\n remote-locators=localhost[%d]", dsId, remoteLocator);
      } else {
        sprintf(gemStr,"distributed-system-id=%d\n ", dsId);
      }
      std::string msg = gemStr;
    }
    /*ACE_OS::*/
    fwrite(msg.c_str(), msg.size(), 1, urandom);
    /*ACE_OS::*/
    fflush(urandom);
    /*ACE_OS::*/
    fclose(urandom);
    LOG( gemfireFile.c_str());
    return gemfireFile;
  }


   CacheHelper* CacheHelper::singleton = NULL;
   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();