| /* |
| * 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_POOLATTRIBUTES_H_ |
| #define GEODE_POOLATTRIBUTES_H_ |
| |
| #include <chrono> |
| #include <string> |
| #include <vector> |
| |
| #include <geode/ExceptionTypes.hpp> |
| #include <geode/internal/geode_globals.hpp> |
| |
| /** |
| * @file |
| */ |
| |
| namespace apache { |
| namespace geode { |
| namespace client { |
| |
| class PoolAttributes { |
| public: |
| PoolAttributes(); |
| |
| const std::chrono::milliseconds& getFreeConnectionTimeout() const { |
| return m_freeConnTimeout; |
| } |
| |
| void setFreeConnectionTimeout( |
| const std::chrono::milliseconds& connectionTimeout) { |
| m_freeConnTimeout = connectionTimeout; |
| } |
| |
| const std::chrono::milliseconds& getLoadConditioningInterval() const { |
| return m_loadCondInterval; |
| } |
| |
| void setLoadConditioningInterval( |
| const std::chrono::milliseconds& loadConditioningInterval) { |
| m_loadCondInterval = loadConditioningInterval; |
| } |
| |
| int getSocketBufferSize() const { return m_sockBufferSize; } |
| |
| void setSocketBufferSize(int bufferSize) { m_sockBufferSize = bufferSize; } |
| |
| const std::chrono::milliseconds& getReadTimeout() const { |
| return m_readTimeout; |
| } |
| |
| void setReadTimeout(const std::chrono::milliseconds& timeout) { |
| m_readTimeout = timeout; |
| } |
| |
| bool getThreadLocalConnectionSetting() { return m_isThreadLocalConn; } |
| |
| void setThreadLocalConnectionSetting(bool isThreadLocal) { |
| m_isThreadLocalConn = isThreadLocal; |
| } |
| |
| int getMinConnections() const { return m_minConns; } |
| |
| void setMinConnections(int minConnections) { m_minConns = minConnections; } |
| |
| int getMaxConnections() const { return m_maxConns; } |
| |
| void setMaxConnections(int maxConnections) { m_maxConns = maxConnections; } |
| |
| const std::chrono::milliseconds& getIdleTimeout() const { |
| return m_idleTimeout; |
| } |
| |
| void setIdleTimeout(const std::chrono::milliseconds& idleTimeout) { |
| m_idleTimeout = idleTimeout; |
| } |
| |
| int getRetryAttempts() const { return m_retryAttempts; } |
| |
| void setRetryAttempts(int retryAttempts) { m_retryAttempts = retryAttempts; } |
| |
| const std::chrono::milliseconds& getPingInterval() const { |
| return m_pingInterval; |
| } |
| |
| void setPingInterval(const std::chrono::milliseconds& pingInterval) { |
| m_pingInterval = pingInterval; |
| } |
| |
| const std::chrono::milliseconds& getUpdateLocatorListInterval() const { |
| return m_updateLocatorListInterval; |
| } |
| |
| void setUpdateLocatorListInterval( |
| const std::chrono::milliseconds& updateLocatorListInterval) { |
| m_updateLocatorListInterval = updateLocatorListInterval; |
| } |
| |
| const std::chrono::milliseconds& getStatisticInterval() const { |
| return m_statsInterval; |
| } |
| |
| void setStatisticInterval( |
| const std::chrono::milliseconds& statisticInterval) { |
| m_statsInterval = statisticInterval; |
| } |
| |
| const std::string& getServerGroup() const { return m_serverGrp; } |
| |
| void setServerGroup(std::string group) { m_serverGrp = group; } |
| |
| bool getSubscriptionEnabled() const { return m_subsEnabled; } |
| |
| void setSubscriptionEnabled(bool enabled) { m_subsEnabled = enabled; } |
| |
| int getSubscriptionRedundancy() const { return m_redundancy; } |
| |
| void setSubscriptionRedundancy(int redundancy) { m_redundancy = redundancy; } |
| |
| const std::chrono::milliseconds& getSubscriptionMessageTrackingTimeout() |
| const { |
| return m_msgTrackTimeout; |
| } |
| |
| void setSubscriptionMessageTrackingTimeout( |
| const std::chrono::milliseconds& messageTrackingTimeout) { |
| m_msgTrackTimeout = messageTrackingTimeout; |
| } |
| |
| const std::chrono::milliseconds& getSubscriptionAckInterval() const { |
| return m_subsAckInterval; |
| } |
| |
| void setSubscriptionAckInterval( |
| const std::chrono::milliseconds& ackInterval) { |
| m_subsAckInterval = ackInterval; |
| } |
| |
| bool getPRSingleHopEnabled() const { return m_isPRSingleHopEnabled; } |
| |
| void setPRSingleHopEnabled(bool enabled) { m_isPRSingleHopEnabled = enabled; } |
| |
| bool getMultiuserSecureModeEnabled() const { return m_multiuserSecurityMode; } |
| |
| void setMultiuserSecureModeEnabled(bool multiuserSecureMode) { |
| m_multiuserSecurityMode = multiuserSecureMode; |
| } |
| |
| void addLocator(const std::string& host, int port); |
| |
| void addServer(const std::string& host, int port); |
| |
| std::shared_ptr<PoolAttributes> clone(); |
| |
| /** Return true if all the attributes are equal to those of other. */ |
| bool operator==(const PoolAttributes& other) const; |
| |
| private: |
| bool m_isThreadLocalConn; |
| std::chrono::milliseconds m_freeConnTimeout; |
| std::chrono::milliseconds m_loadCondInterval; |
| int m_sockBufferSize; |
| std::chrono::milliseconds m_readTimeout; |
| int m_minConns; |
| int m_maxConns; |
| int m_retryAttempts; |
| std::chrono::milliseconds m_statsInterval; |
| int m_redundancy; |
| std::chrono::milliseconds m_msgTrackTimeout; |
| std::chrono::milliseconds m_subsAckInterval; |
| |
| std::chrono::milliseconds m_idleTimeout; |
| std::chrono::milliseconds m_pingInterval; |
| std::chrono::milliseconds m_updateLocatorListInterval; |
| |
| bool m_subsEnabled; |
| bool m_multiuserSecurityMode; |
| bool m_isPRSingleHopEnabled; |
| |
| std::string m_serverGrp; |
| std::vector<std::string> m_initLocList; |
| std::vector<std::string> m_initServList; |
| |
| static bool compareVectorOfStrings( |
| const std::vector<std::string>& thisVector, |
| const std::vector<std::string>& otherVector); |
| |
| friend class ThinClientPoolDM; |
| }; |
| } // namespace client |
| } // namespace geode |
| } // namespace apache |
| |
| #endif // GEODE_POOLATTRIBUTES_H_ |