SystemProperties.hpp

Go to the documentation of this file.

#pragma once
 
#ifndef GEODE_SYSTEMPROPERTIES_H_
#define GEODE_SYSTEMPROPERTIES_H_
 
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#include "Properties.hpp"
#include "Log.hpp"
#include "AuthInitialize.hpp"
 
namespace apache {
namespace geode {
namespace client {
 
// Factory function typedefs to register the managed authInitialize
typedef AuthInitialize* (*LibraryAuthInitializeFn)(const char* assemblyPath,
                                                   const char* factFuncName);
 
class CPPCACHE_EXPORT SystemProperties {
 public:
  SystemProperties(const PropertiesPtr& propertiesPtr,
                   const char* configFile = NULL);
 
  ~SystemProperties();
 
  void logSettings();
 
  const uint32_t threadPoolSize() const { return m_threadPoolSize; }
 
  const uint32_t statisticsSampleInterval() const {
    return m_statisticsSampleInterval;
  }
 
  bool statisticsEnabled() const { return m_statisticsEnabled; }
 
  bool sslEnabled() const { return m_sslEnabled; }
 
  bool sslStrictMode() const { return m_sslStrictMode; }
 
  bool getEnableTimeStatistics() const /*timestatisticsEnabled()*/
  {
    return m_timestatisticsEnabled;
  } /*m_timestatisticsEnabled*/
 
  const char* sslKeyStore() const { return m_sslKeyStore; }
 
  const char* sslKeystorePassword() const { return m_sslKeystorePassword; }
 
  const char* sslTrustStore() const { return m_sslTrustStore; }
 
  const char* statisticsArchiveFile() const { return m_statisticsArchiveFile; }
 
  const char* logFilename() const { return m_logFilename; }
 
  Log::LogLevel logLevel() const { return m_logLevel; }
 
  const bool heapLRULimitEnabled() const { return (m_heapLRULimit > 0); }
 
  const size_t heapLRULimit() const { return m_heapLRULimit; }
 
  const int32_t heapLRUDelta() const { return m_heapLRUDelta; }
  const int32_t maxSocketBufferSize() const { return m_maxSocketBufferSize; }
 
  const int32_t pingInterval() const { return m_pingInterval; }
  const int32_t redundancyMonitorInterval() const {
    return m_redundancyMonitorInterval;
  }
 
  const int32_t notifyAckInterval() const { return m_notifyAckInterval; }
 
  const int32_t notifyDupCheckLife() const { return m_notifyDupCheckLife; }
 
  const char* durableClientId() const { return m_durableClientId; }
 
  const uint32_t durableTimeout() const { return m_durableTimeout; }
 
  const uint32_t connectTimeout() const { return m_connectTimeout; }
 
  const uint32_t connectWaitTimeout() const { return m_connectWaitTimeout; }
 
  const uint32_t bucketWaitTimeout() const { return m_bucketWaitTimeout; }
 
  char* conflateEvents() { return m_conflateEvents; }
 
  const bool debugStackTraceEnabled() const { return m_debugStackTraceEnabled; }
 
  inline const bool crashDumpEnabled() const { return m_crashDumpEnabled; }
 
  const char* name() const { return m_name; }
 
  const char* cacheXMLFile() const { return m_cacheXMLFile; }
 
  const uint32_t logFileSizeLimit() const { return m_logFileSizeLimit; }
 
  const uint32_t logDiskSpaceLimit() const { return m_logDiskSpaceLimit; }
 
  const uint32_t statsFileSizeLimit() const { return m_statsFileSizeLimit; }
 
  const uint32_t statsDiskSpaceLimit() const { return m_statsDiskSpaceLimit; }
 
  const uint32_t maxQueueSize() { return m_maxQueueSize; }
 
  const uint32_t javaConnectionPoolSize() const {
    return m_javaConnectionPoolSize;
  }
  void setjavaConnectionPoolSize(uint32_t size) {
    m_javaConnectionPoolSize = size;
  }
 
  bool disableChunkHandlerThread() const { return m_disableChunkHandlerThread; }
 
  bool readTimeoutUnitInMillis() const { return m_readTimeoutUnitInMillis; }
 
  void setDisableChunkHandlerThread(bool set) {
    m_disableChunkHandlerThread = set;
  }
 
  bool onClientDisconnectClearPdxTypeIds() const {
    return m_onClientDisconnectClearPdxTypeIds;
  }
 
  void setOnClientDisconnectClearPdxTypeIds(bool set) {
    m_onClientDisconnectClearPdxTypeIds = set;
  }
 
  inline const char* authInitLibrary() const {
    return (m_AuthIniLoaderLibrary == NULLPTR
                ? ""
                : m_AuthIniLoaderLibrary->asChar());
  }
 
  inline const char* authInitFactory() const {
    return (m_AuthIniLoaderFactory == NULLPTR
                ? ""
                : m_AuthIniLoaderFactory->asChar());
  }
 
  const char* securityClientDhAlgo() {
    return (m_securityClientDhAlgo == NULLPTR
                ? ""
                : m_securityClientDhAlgo->asChar());
  }
 
  const char* securityClientKsPath() {
    return (m_securityClientKsPath == NULLPTR
                ? ""
                : m_securityClientKsPath->asChar());
  }
 
  PropertiesPtr getSecurityProperties() const {
    return m_securityPropertiesPtr;
  }
 
  inline bool isSecurityOn() const {
    return (m_AuthIniLoaderFactory != NULLPTR &&
            m_AuthIniLoaderLibrary != NULLPTR);
  }
 
  inline bool isEndpointShufflingDisabled() const {
    return m_disableShufflingEndpoint;
  }
 
  bool isDhOn() {
    return isSecurityOn() && m_securityClientDhAlgo != NULLPTR &&
           m_securityClientDhAlgo->length() > 0;
  }
 
  inline bool isGridClient() const { return m_gridClient; }
 
  inline bool isAppDomainEnabled() const { return m_appDomainEnabled; }
 
  inline bool autoReadyForEvents() const { return m_autoReadyForEvents; }
 
  const uint32_t suspendedTxTimeout() const { return m_suspendedTxTimeout; }
 
  const uint32_t tombstoneTimeoutInMSec() const {
    return m_tombstoneTimeoutInMSec;
  }
 
 private:
  uint32_t m_statisticsSampleInterval;
 
  bool m_statisticsEnabled;
 
  bool m_appDomainEnabled;
 
  char* m_statisticsArchiveFile;
 
  char* m_logFilename;
 
  Log::LogLevel m_logLevel;
 
  int m_sessions;
 
  char* m_name;
 
  bool m_debugStackTraceEnabled;
 
  bool m_crashDumpEnabled;
 
  bool m_disableShufflingEndpoint;
 
  char* m_cacheXMLFile;
 
  uint32_t m_logFileSizeLimit;
  uint32_t m_logDiskSpaceLimit;
 
  uint32_t m_statsFileSizeLimit;
  uint32_t m_statsDiskSpaceLimit;
 
  uint32_t m_maxQueueSize;
  uint32_t m_javaConnectionPoolSize;
 
  int32_t m_heapLRULimit;
  int32_t m_heapLRUDelta;
  int32_t m_maxSocketBufferSize;
  int32_t m_pingInterval;
  int32_t m_redundancyMonitorInterval;
 
  int32_t m_notifyAckInterval;
  int32_t m_notifyDupCheckLife;
 
  PropertiesPtr m_securityPropertiesPtr;
  CacheableStringPtr m_AuthIniLoaderLibrary;
  CacheableStringPtr m_AuthIniLoaderFactory;
  CacheableStringPtr m_securityClientDhAlgo;
  CacheableStringPtr m_securityClientKsPath;
  AuthInitializePtr m_authInitializer;
 
  char* m_durableClientId;
  uint32_t m_durableTimeout;
 
  uint32_t m_connectTimeout;
  uint32_t m_connectWaitTimeout;
  uint32_t m_bucketWaitTimeout;
 
  bool m_gridClient;
 
  bool m_autoReadyForEvents;
 
  bool m_sslEnabled;
  bool m_sslStrictMode;
  bool m_timestatisticsEnabled;
  char* m_sslKeyStore;
  char* m_sslTrustStore;
 
  char* m_sslKeystorePassword;
 
  char* m_conflateEvents;
 
  uint32_t m_threadPoolSize;
  uint32_t m_suspendedTxTimeout;
  uint32_t m_tombstoneTimeoutInMSec;
  bool m_disableChunkHandlerThread;
  bool m_readTimeoutUnitInMillis;
  bool m_onClientDisconnectClearPdxTypeIds;
 
 private:
  void processProperty(const char* property, const char* value);
 
  AuthInitializePtr getAuthLoader();
 
 private:
  SystemProperties(const SystemProperties& rhs);  // never defined
  void operator=(const SystemProperties& rhs);    // never defined
 
  void throwError(const char* msg);
 
 public:
  static LibraryAuthInitializeFn managedAuthInitializeFn;
 
  friend class DistributedSystemImpl;
};
}  // namespace client
}  // namespace geode
}  // namespace apache
 
#endif  // GEODE_SYSTEMPROPERTIES_H_