SystemProperties.hpp

Go to the documentation of this file.

/*
 * 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_SYSTEMPROPERTIES_H_
#define GEODE_SYSTEMPROPERTIES_H_
 
#include "Properties.hpp"
#include "util/LogLevel.hpp"
 
namespace apache {
namespace geode {
namespace client {
 
class APACHE_GEODE_EXPORT SystemProperties {
 public:
  explicit SystemProperties(const std::shared_ptr<Properties>& propertiesPtr,
                            const std::string& configFile = "");
 
  SystemProperties(const SystemProperties& rhs) = delete;
  void operator=(const SystemProperties& rhs) = delete;
 
  ~SystemProperties();
 
  void logSettings();
 
  uint32_t threadPoolSize() const { return m_threadPoolSize; }
 
  const std::chrono::milliseconds statisticsSampleInterval() const {
    return m_statisticsSampleInterval;
  }
 
  bool statisticsEnabled() const { return m_statisticsEnabled; }
 
  bool sslEnabled() const { return m_sslEnabled; }
 
  bool getEnableTimeStatistics() const { return m_timestatisticsEnabled; }
 
  const std::string& sslKeyStore() const { return m_sslKeyStore; }
 
  const std::string& sslKeystorePassword() const {
    return m_sslKeystorePassword;
  }
 
  const std::string& sslTrustStore() const { return m_sslTrustStore; }
 
  const std::string& statisticsArchiveFile() const {
    return m_statisticsArchiveFile;
  }
 
  const std::string& logFilename() const { return m_logFilename; }
 
  LogLevel logLevel() const { return m_logLevel; }
 
  void setLogLevel(LogLevel newLogLevel) { m_logLevel = newLogLevel; }
 
  bool heapLRULimitEnabled() const { return (m_heapLRULimit > 0); }
 
  size_t heapLRULimit() const { return m_heapLRULimit; }
 
  int32_t heapLRUDelta() const { return m_heapLRUDelta; }
 
  int32_t maxSocketBufferSize() const { return m_maxSocketBufferSize; }
 
  const std::chrono::seconds& pingInterval() const { return m_pingInterval; }
 
  const std::chrono::seconds& redundancyMonitorInterval() const {
    return m_redundancyMonitorInterval;
  }
 
  const std::chrono::milliseconds& notifyAckInterval() const {
    return m_notifyAckInterval;
  }
 
  const std::chrono::milliseconds& notifyDupCheckLife() const {
    return m_notifyDupCheckLife;
  }
 
  const std::string& durableClientId() const { return m_durableClientId; }
 
  const std::chrono::seconds& durableTimeout() const {
    return m_durableTimeout;
  }
 
  const std::chrono::milliseconds& connectTimeout() const {
    return m_connectTimeout;
  }
 
  const std::chrono::milliseconds& connectWaitTimeout() const {
    return m_connectWaitTimeout;
  }
 
  const std::chrono::milliseconds& bucketWaitTimeout() const {
    return m_bucketWaitTimeout;
  }
 
  const std::string& conflateEvents() const { return m_conflateEvents; }
 
  const std::string& name() const { return m_name; }
 
  const std::string& cacheXMLFile() const { return m_cacheXMLFile; }
 
  uint32_t logFileSizeLimit() const { return m_logFileSizeLimit; }
 
  uint32_t logDiskSpaceLimit() const { return m_logDiskSpaceLimit; }
 
  uint32_t statsFileSizeLimit() const { return m_statsFileSizeLimit; }
 
  uint32_t statsDiskSpaceLimit() const { return m_statsDiskSpaceLimit; }
 
  uint32_t connectionPoolSize() const { return m_connectionPoolSize; }
  void setjavaConnectionPoolSize(uint32_t size) { m_connectionPoolSize = size; }
 
  bool enableChunkHandlerThread() const { return m_enableChunkHandlerThread; }
 
  void setEnableChunkHandlerThread(bool set) {
    m_enableChunkHandlerThread = set;
  }
 
  bool onClientDisconnectClearPdxTypeIds() const {
    return m_onClientDisconnectClearPdxTypeIds;
  }
 
  void setOnClientDisconnectClearPdxTypeIds(bool set) {
    m_onClientDisconnectClearPdxTypeIds = set;
  }
 
  _GEODE_DEPRECATED_(
      "Diffie-Hellman based credentials encryption is not supported.")
  const std::string& securityClientDhAlgo() const {
    return m_securityClientDhAlgo;
  }
 
  const std::string& securityClientKsPath() const {
    return m_securityClientKsPath;
  }
 
  std::shared_ptr<Properties> getSecurityProperties() const {
    return m_securityPropertiesPtr;
  }
 
  inline bool isEndpointShufflingDisabled() const {
    return m_disableShufflingEndpoint;
  }
 
  _GEODE_DEPRECATED_(
      "Diffie-Hellman based credentials encryption is not supported.")
  bool isDhOn() const { return false; }
 
  inline bool autoReadyForEvents() const { return m_autoReadyForEvents; }
 
  const std::chrono::seconds suspendedTxTimeout() const {
    return m_suspendedTxTimeout;
  }
 
  const std::chrono::milliseconds tombstoneTimeout() const {
    return m_tombstoneTimeout;
  }
 
 private:
  std::chrono::milliseconds m_statisticsSampleInterval;
 
  bool m_statisticsEnabled;
 
  std::string m_statisticsArchiveFile;
 
  std::string m_logFilename;
 
  LogLevel m_logLevel;
 
  int m_sessions;
 
  std::string m_name;
 
  bool m_disableShufflingEndpoint;
 
  std::string m_cacheXMLFile;
 
  uint32_t m_logFileSizeLimit;
  uint32_t m_logDiskSpaceLimit;
 
  uint32_t m_statsFileSizeLimit;
  uint32_t m_statsDiskSpaceLimit;
 
  uint32_t m_connectionPoolSize;
 
  int32_t m_heapLRULimit;
  int32_t m_heapLRUDelta;
  int32_t m_maxSocketBufferSize;
  std::chrono::seconds m_pingInterval;
  std::chrono::seconds m_redundancyMonitorInterval;
 
  std::chrono::milliseconds m_notifyAckInterval;
  std::chrono::milliseconds m_notifyDupCheckLife;
 
  std::shared_ptr<Properties> m_securityPropertiesPtr;
 
  std::string m_securityClientDhAlgo;
  std::string m_securityClientKsPath;
 
  std::string m_durableClientId;
  std::chrono::seconds m_durableTimeout;
 
  std::chrono::milliseconds m_connectTimeout;
  std::chrono::milliseconds m_connectWaitTimeout;
  std::chrono::milliseconds m_bucketWaitTimeout;
 
  bool m_autoReadyForEvents;
 
  bool m_sslEnabled;
  bool m_timestatisticsEnabled;
  std::string m_sslKeyStore;
  std::string m_sslTrustStore;
 
  std::string m_sslKeystorePassword;
 
  std::string m_conflateEvents;
 
  uint32_t m_threadPoolSize;
  std::chrono::seconds m_suspendedTxTimeout;
  std::chrono::milliseconds m_tombstoneTimeout;
  bool m_enableChunkHandlerThread;
  bool m_onClientDisconnectClearPdxTypeIds;
 
  void processProperty(const std::string& property, const std::string& value);
  static bool parseBooleanProperty(const std::string& property,
                                   const std::string& value);
  template <class _Rep, class _Period>
  static void parseDurationProperty(
      const std::string& property, const std::string& value,
      std::chrono::duration<_Rep, _Period>& duration);
 
  [[noreturn]] static void throwError(const std::string& msg);
 
 public:
  friend class DistributedSystemImpl;
};
}  // namespace client
}  // namespace geode
}  // namespace apache
 
#endif  // GEODE_SYSTEMPROPERTIES_H_