////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef __SERVER_CONFIG_H__
#define __SERVER_CONFIG_H__
#include "Utils/Serializer.h"
#include <chrono>
class ServerConfig : public SerializedBase
{
JSON_SERIALIZED()
public:
explicit ServerConfig(bool productionConfig = true) : m_autoReset(!productionConfig), m_cheatsEnabled(true), m_canClientDisableInactivityCheck(!productionConfig)
{
}
// credentials
inline const std::string& GetUsername() const { return m_username; }
inline const std::string& GetPassword() const { return m_password; }
inline const std::string& GetScope() const { return m_scope; }
inline const std::string& GetClientId() const { return m_clientId; }
inline const std::string& GetDataCenterName() const { return m_dataCenterName; }
// client rates
inline std::chrono::milliseconds GetClientPingInterval() const { return m_clientPingInterval; }
inline std::chrono::milliseconds GetAbandonConnectionThreshold() const { return m_adbandonConnectionThreshold; }
inline std::chrono::milliseconds GetInDangerThreshold() const { return m_inDangerThreshold; }
// rates
inline std::chrono::milliseconds GetServerPingInterval() const { return m_serverPingInterval; }
inline std::chrono::milliseconds GetSaveInterval() const { return m_saveInterval; }
inline std::chrono::milliseconds GetForceSaveInterval() const { return m_forceSaveInterval; }
inline uint32_t GetForceSaveCount() const { return m_forceSaveCount; }
inline std::chrono::milliseconds GetMatchmakingInterval() const { return m_matchmakingInterval; }
inline std::chrono::milliseconds GetOpponentUpdateInterval() const { return m_opponentUpdateInterval; }
inline std::chrono::milliseconds GetProfileLockedRetryInterval() const { return m_profileLockedRetryInterval; }
inline std::chrono::milliseconds GetMaxFinalProfileFlushTime() const { return m_maxFinalProfileFlushTime; }
inline std::chrono::milliseconds GetMaxFinalSetInventoryValuesTime() const { return m_maxFinalSetInventoryValuesTime; }
inline uint32_t GetMaxFinalSyncInventoryRetries() const { return m_maxFinalSyncInventoryRetries; }
// on player level-up, sync this to standard matcher location and do a CRM refresh possibly multiple times to make sure it really updates for timely campaigns based on player level
inline std::vector<std::chrono::milliseconds> GetLevelUpCrmRefreshTimeArray() const { return m_levelUpCrmRefreshTimeArray; }
// internals
inline std::chrono::milliseconds GetRecvTimeout() const { return m_recvTimeout; }
inline uint32_t GetUpdateFrequencyHz() const { return m_updateFrequencyHz; }
inline uint32_t GetSvnRevision() const { return m_svnRevision; }
inline uint32_t GetTargetSendBufferSize() const { return m_targetSendBuffer; }
inline uint32_t GetTargetRecieveBufferSize() const { return m_targetRecvBuffer; }
inline uint32_t GetResizeThreshold() const { return m_resizeThreshold; }
inline uint32_t GetThreadPoolSize() const { return m_threadPoolSize; }
inline bool AllowClientToDisableInactivityCheck() const { return m_canClientDisableInactivityCheck; }
inline std::chrono::milliseconds GetCrmConfigIntervalCheck() const { return m_crmCfgIntervalCheck; }
inline const std::string& GetServerVersion() const { return m_version; }
inline void SetServerVersion(const std::string& v) { m_version = v; }
// logging
inline size_t GetLogLevel() const { return static_cast<size_t>(m_logLevel); }
inline bool GetMessageStatsEnabled() const { return m_messageStatsEnabled; }
inline bool SendServerSideTrackingEnabled() const { return m_sendSeverSideTrackersEnabled; }
inline const std::vector<uint32_t>& ServerSideGlotTrackingEventIDs() const { return m_serverSideGlotTrackingEventIDs; }
// gameplay
inline bool GetAutoReset() const { return m_autoReset; }
inline bool CheatsEnabled() const { return m_cheatsEnabled; }
inline bool IsDBCacheEnabled() const { return m_cacheDB; }
inline std::chrono::milliseconds DBCacheRefreshTimeout() const { return m_cacheDBRefreshTimeout; }
// security
void ApplySecurityLock(const ServerConfig& lock);
inline const std::vector<std::string>& GetAllowedClientIdList() const { return m_allowedClientIds; }
inline bool GetBatchProfileMigrationAllowed() const { return m_batchProfileMigrationAllowed; }
// leaderboard
inline std::string GetLeagueLeaderboardName() const { return m_leagueLeaderboardName; }
inline std::string GetGlobalLeaderboardName() const { return m_globalLeaderboardName; }
inline std::string GetLocalLeaderboardName() const { return m_localLeaderboardName; }
inline Timestamp GetLeagueLeaderboardBaseTime() const { return m_leagueLeaderboardBaseTime; }
inline std::chrono::milliseconds GetLeagueLeaderboardDuration() const { return m_leagueLeaderboardDuration; }
inline const bne::JsonValueConstRef GetLeagueLeaderboardTierJson() const { return m_leagueLeaderboardTierJson; }
inline uint32_t GetGeoLocationLeaderboardDistance() const { return m_geoLocationLeaderboardDistance; }
inline bool GetGeoLocationLeaderboardCenterOnUser() const { return m_geoLocationLeaderboardCenterOnUser; }
// seshat
inline const std::vector<std::string>& GetSehatMatcherList() const { return m_matcherList; }
inline std::string GetSehatMatcherIncludes() const { return m_matcherIncludes; }
inline bool ShouldSortMatchesByDifficulty() const { return m_bSortMatchesByDifficulty; }
inline std::string GetForcedCompatibilitySuffix() const { return m_forcedCompatiblitySuffix; }
inline std::string GetForcedCompatibilityHash() const { return m_forcedCompatiblityHash; }
inline uint32_t GetMaxOpponentPlayerLevelsAbove() const { return m_maxOpponentPlayerLevelsAbove; }
inline uint32_t GetMaxOpponentPlayerLevelsBelow() const { return m_maxOpponentPlayerLevelsBelow; }
inline uint32_t GetMaxOpponentTrophiesAbove() const { return m_maxOpponentTrophiesAbove; }
inline uint32_t GetMaxOpponentTrophiesBelow() const { return m_maxOpponentTrophiesBelow; }
inline uint32_t GetTargetFreeOpponentSize() const { return m_targetFreeOpponentSize; }
// tracking
inline bool ShouldSendServerSideTrackingEvents() const { return m_bSendServerSideTrackingEvents; }
inline std::chrono::milliseconds GetTrackingUpdatePeriodSecs() const { return m_targetUpdatePeriod; }
inline std::chrono::milliseconds GetTrackingInitEvePeriodSecs() const { return m_targetInitEvePeriod; }
inline std::chrono::milliseconds GetTrackingFlushPeriodSecs() const { return m_flushEventPeriod; }
inline uint32_t GetTrackingMaxPendingQueueSize() const { return m_maxPendingPackages; }
void EraseSensitiveInformation()
{
m_username = "";
m_password = "";
}
// Clan/Crew
inline const std::string & GetClanLeaderboardName() const { return m_clanLeaderboardName; }
inline const std::string & GetClanCategoryName() const { return m_clanCategoryName; }
inline std::chrono::milliseconds GetClanStatusIntervalCheckMs() const { return m_clanStatusIntervalCheck; }
inline std::chrono::milliseconds GetClanWallPostLifeTimeSecs() const { return m_clanWallPostLifeTime; }
// notifications
inline const std::string & GetNotificationType() const { return m_notificationType; }
inline const std::string & GetNotificationWnsType() const { return m_notificationWnsType; }
// shields
inline uint32_t GetShieldAttackThresholdCount() const { return m_ShieldAttackThresholdCount; }
inline std::chrono::milliseconds GetShieldAttackThresholdDurationSecs() const { return m_ShieldAttackThresholdDuration; }
inline std::chrono::milliseconds GetShieldDurationSecs() const { return m_ShieldDuration; }
// crm
inline const std::vector<std::string>& GetAgeLimitationCountries() const { return m_ageLimitationCountries; }
protected:
inline void SetDefaultTierJson(const std::string& lbName)
{
m_leagueLeaderboardTierJson = lbName;
}
inline void SetUserName(const std::string & a_sDataVal) { m_username = a_sDataVal; }
inline void SetPassword(const std::string & a_sDataVal) { m_password = a_sDataVal; }
inline void SetScope(const std::string & a_sDataVal) { m_scope = a_sDataVal; }
inline void SetClientId(const std::string & a_sDataVal) { m_clientId = a_sDataVal; }
inline void SetDataCenter(const std::string & a_sDataVal) { m_dataCenterName = a_sDataVal; }
inline void SetSvnRevision(uint32_t a_uiRevision) { m_svnRevision = a_uiRevision; }
inline void SetLogLevel(RKLogLevel a_LogVal) { m_logLevel = a_LogVal; }
inline void SetMatcherList(const std::vector<std::string> & a_vMatcherList) { m_matcherList = a_vMatcherList; }
inline void SetMatcherIncludes(const std::string & a_sDataVal) { m_matcherIncludes = a_sDataVal; }
inline void SetLevelUpCRMRefresh(const std::vector<std::chrono::milliseconds> & a_vRefreshTimes) { m_levelUpCrmRefreshTimeArray = a_vRefreshTimes; }
inline void SetAllowedClientIds(const std::vector<std::string> & a_vClientIds) { m_allowedClientIds = a_vClientIds; }
inline void SetLeagueLeaderboardName(const std::string & a_sDataVal) { m_leagueLeaderboardName = a_sDataVal; }
inline void SetGlobalLeaderboardName(const std::string & a_sDataVal) { m_globalLeaderboardName = a_sDataVal; }
inline void SetLocalLeaderboardName(const std::string & a_sDataVal) { m_localLeaderboardName = a_sDataVal; }
inline void SetLeagueLeaderboardBaseTime(const Timestamp & a_DataVal) { m_leagueLeaderboardBaseTime = a_DataVal; }
inline void SetLeagueLeaderboardDuration(std::chrono::milliseconds a_uiDataValInSecs) { m_leagueLeaderboardDuration = a_uiDataValInSecs; }
inline void SetGeolocationLeaderboardCenterOnUser(bool a_bDataVal) { m_geoLocationLeaderboardCenterOnUser = a_bDataVal; }
inline void SetGeolocationLeaderboardDistance(uint32_t a_uiDataVal) { m_geoLocationLeaderboardDistance = a_uiDataVal; }
inline void SetClanCategoryName(const std::string & a_sDataVal) { m_clanCategoryName = a_sDataVal; }
inline void SetClanLeaderboardName(const std::string & a_sDataVal) { m_clanLeaderboardName = a_sDataVal; }
inline void SetClanStatusIntervalCheck(std::chrono::milliseconds a_uiDataVal) { m_clanStatusIntervalCheck = a_uiDataVal; }
inline void SetClanWallPostListTime(std::chrono::milliseconds a_iDataVal) { m_clanWallPostLifeTime = a_iDataVal; }
inline void SetForcedCompabilitySuffix(const std::string & a_sDataVal) { m_forcedCompatiblitySuffix = a_sDataVal; }
inline void SetForcedCompabilityHash(const std::string & a_sDataVal) { m_forcedCompatiblityHash = a_sDataVal; }
inline void SetAutoReset(bool a_bDataVal) { m_autoReset = a_bDataVal; }
inline void SetCheatsEnabled(bool a_bDataVal) { m_cheatsEnabled = a_bDataVal; }
inline void SetCanClientDisabledInactivityCheck(bool a_bDataVal) { m_canClientDisableInactivityCheck = a_bDataVal; }
private:
std::string m_username;
std::string m_password;
std::string m_scope;
std::string m_clientId;
std::string m_dataCenterName;
// rates
std::chrono::milliseconds m_serverPingInterval = std::chrono::seconds(1); // 1s
// client rates
std::chrono::milliseconds m_clientPingInterval = std::chrono::seconds(1); // 1s
#ifdef _DEBUG
std::chrono::milliseconds m_adbandonConnectionThreshold = std::chrono::seconds(5);
std::chrono::milliseconds m_inDangerThreshold = std::chrono::seconds(2);
#else
std::chrono::milliseconds m_adbandonConnectionThreshold = std::chrono::seconds(5);
std::chrono::milliseconds m_inDangerThreshold = std::chrono::seconds(2);
#endif
// base intervals
std::chrono::milliseconds m_expectedLongestFedRequestTime = std::chrono::seconds(15); // some timeouts need to be based on max
std::chrono::milliseconds m_baseInterval = std::chrono::seconds(15); // used as value other values are based on
std::chrono::milliseconds m_saveInterval = m_baseInterval * 20;
std::chrono::milliseconds m_forceSaveInterval = m_baseInterval * 2;
std::chrono::milliseconds m_matchmakingInterval = m_baseInterval * 4;
std::chrono::milliseconds m_opponentUpdateInterval = m_baseInterval * 60;
std::chrono::milliseconds m_profileLockedRetryInterval = m_baseInterval * 4;
std::chrono::milliseconds m_maxFinalProfileFlushTime = m_expectedLongestFedRequestTime * 8;
std::chrono::milliseconds m_maxFinalSetInventoryValuesTime = m_expectedLongestFedRequestTime;
std::vector<std::chrono::milliseconds> m_levelUpCrmRefreshTimeArray;
uint32_t m_forceSaveCount = 5;
uint32_t m_maxFinalSyncInventoryRetries = 3;
// internals
std::chrono::milliseconds m_recvTimeout = std::chrono::milliseconds(100);
uint32_t m_updateFrequencyHz = 30; // Hz
uint32_t m_svnRevision = 0;
uint32_t m_targetSendBuffer = 4096;
uint32_t m_targetRecvBuffer = 2048;
uint32_t m_resizeThreshold = 20;
uint32_t m_threadPoolSize = 32;
std::chrono::milliseconds m_crmCfgIntervalCheck = std::chrono::seconds(20 * 60); // Check the hestia/CRM config at 20 mins interval by default
std::string m_version;
// logging
RKLogLevel m_logLevel = RKLL_UNKNOWN;
bool m_messageStatsEnabled = false;
bool m_sendSeverSideTrackersEnabled = false;
std::vector<uint32_t> m_serverSideGlotTrackingEventIDs;
bool m_cacheDB = false;
std::chrono::milliseconds m_cacheDBRefreshTimeout = std::chrono::seconds(15 * 60); // 15 min
// gameplay
bool m_autoReset = false;
bool m_cheatsEnabled = false;
// security
bool m_canClientDisableInactivityCheck = false;
// security
std::vector<std::string> m_allowedClientIds;
bool m_batchProfileMigrationAllowed = false;
// leaderboard
std::string m_leagueLeaderboardName;
std::string m_globalLeaderboardName;
std::string m_localLeaderboardName;
Timestamp m_leagueLeaderboardBaseTime;
std::chrono::milliseconds m_leagueLeaderboardDuration = std::chrono::seconds(0);
uint32_t m_geoLocationLeaderboardDistance = 0;
bool m_geoLocationLeaderboardCenterOnUser = false; // if true the leaderboard data will be centered on the user who made the request.
bne::JsonValue m_leagueLeaderboardTierJson;
// Crew
std::string m_clanCategoryName;
std::string m_clanLeaderboardName;
std::chrono::milliseconds m_clanWallPostLifeTime = std::chrono::seconds(0); // Wall post older than this will be deleted in seconds
std::chrono::milliseconds m_clanStatusIntervalCheck = std::chrono::seconds(0);
// seshat
std::vector<std::string> m_matcherList;
std::string m_matcherIncludes;
bool m_bSortMatchesByDifficulty = false;
std::string m_forcedCompatiblitySuffix;
std::string m_forcedCompatiblityHash;
uint32_t m_maxOpponentPlayerLevelsAbove = 3;
uint32_t m_maxOpponentPlayerLevelsBelow = 3;
uint32_t m_maxOpponentTrophiesAbove = std::numeric_limits<uint32_t>::max();
uint32_t m_maxOpponentTrophiesBelow = std::numeric_limits<uint32_t>::max();
uint32_t m_targetFreeOpponentSize = 12;
// tracking
bool m_bSendServerSideTrackingEvents = false; // Is server-side tracking turned on?
std::chrono::milliseconds m_targetUpdatePeriod = std::chrono::seconds(30); // The time period between polling the client connection event queues for new events.
std::chrono::milliseconds m_targetInitEvePeriod = std::chrono::seconds(30); // The time period between polling eve for the etsv2 url at startup
std::chrono::milliseconds m_flushEventPeriod = std::chrono::seconds(40); // The time period we wait before sending tracking event batch that's not full.
uint32_t m_maxPendingPackages = 100; // The maximum internal message queue size.. each element can have 100 events.. so it's really 10,000
// notifications
std::string m_notificationType = "launch"; // temp default until Android Framework is patched.
std::string m_notificationWnsType = "";
// shields
uint32_t m_ShieldAttackThresholdCount = 3; // the number of attacks in a given period before shield is activated
std::chrono::milliseconds m_ShieldAttackThresholdDuration = std::chrono::seconds(86400); // the period over which to consider the count
std::chrono::milliseconds m_ShieldDuration = std::chrono::seconds(21600); // the duration the shield will be in effect once active
// CRM
std::vector<std::string> m_ageLimitationCountries;
};
#endif //__SERVER_CONFIG_H__
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
