bcjang/caliverse_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

초기커밋

Browse Source
This commit is contained in:
bcjang
2025-05-01 07:20:41 +09:00
commit 98bb2e3c5c
2747 changed files with 646947 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

773
ServerBase/ServerMetrics/ServerMetricsHandler.cs Normal file
View File

@@ -0,0 +1,773 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using StackExchange.Redis;
using ServerCore; using ServerBase;
using REDIS_REQUEST_HANDLER_TYPE = System.UInt32;
using REDIS_KEY_FORMAT_TYPE = System.UInt32;
using REDIS_KEY_FORMAT = System.String;
using REDIS_KEY_PLACE_HOLDER = System.String;
using REDIS_KEY_REPLACE = System.String;
using REDIS_KEY = System.String;
using WORLD_META_ID = System.UInt32;
using SERVER_NAME = System.String;
using ServerControlCenter;
using System.Drawing;
namespace ServerBase;
/*=================================================================================================
* Server Metrics Key
SET :
+ Channel
serverinfo:Keys:{ChannelKey}:{WorldMetaId}
MEMBER
serverinfo:{Channel}:{WorldId}:{ChannelNo}
+ Etc
serverinfo:Keys:{ServerTypeKey}
MEMBER
serverinfo:{ServerType}:{IP}_{Port}
=================================================================================================*/
public class ServerMetricsHandler : ServerMetricsCacheRequest
{
// for RedisRequest 종류
private enum HandlerType
{
InitByServerKeyWithServerName,
GetByServerKey,
GetByServerName,
RemoveByServerKey,
RemoveByServerName,
UpdateByServerName,
}
// for RedisKey 종류
private enum KeyType
{
Default,
ChannelsInWorld,
ServerName,
}
public readonly string KEY_DEFAULT_FORMAT = $"serverinfo:Keys:{{ServerTypeKey}}";
public readonly string KEY_CHANNELS_IN_WORLD_FORMAT = $"serverinfo:Keys:{{ServerTypeKey}}:{{WorldMetaId}}";
public readonly string KEY_SERVER_NAME_FORMAT = $"serverinfo:{{ServerName}}";
private string serverType2ServerKeyType(ServerType serverType)
{
if (ServerType.Login == serverType) { return "LoginKey"; }
else if (ServerType.Channel == serverType) { return "ChannelKey"; }
else if (ServerType.Indun == serverType) { return "IndunKey"; }
else { throw new TypeAccessException($"Invalid ServerType : {serverType}"); }
}
private (KeyType, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>) buildRedisKeyByServerInfo(ServerType serverType, WORLD_META_ID worldMetaId = 0)
{
var key_type = KeyType.Default;
var redis_key = new Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>();
redis_key.Add("ServerTypeKey", serverType2ServerKeyType(serverType));
if (ServerType.Channel == serverType)
{
key_type = KeyType.ChannelsInWorld;
redis_key.Add("WorldMetaId", worldMetaId.ToString("000"));
}
return (key_type, redis_key);
}
private (KeyType, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>) buildRedisKeyByServerInfo(SERVER_NAME serverName)
{
var redis_key = new Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>();
redis_key.Add("ServerName", serverName);
return (KeyType.ServerName, redis_key);
}
public ServerMetricsHandler(ServerMetricsManager manager, RedisConnector redisConnector)
: base(manager, redisConnector)
{
var default_format = new RedisKeyFormat((uint)KeyType.Default, KEY_DEFAULT_FORMAT);
var channels_in_world_format = new RedisKeyFormat((uint)KeyType.ChannelsInWorld, KEY_CHANNELS_IN_WORLD_FORMAT);
var server_name_format = new RedisKeyFormat((uint)KeyType.ServerName, KEY_SERVER_NAME_FORMAT);
//=========================================================================================
// for RedisRequest Handler
//=========================================================================================
registerRequestHandler( (uint)HandlerType.InitByServerKeyWithServerName, new RedisKeyFormat[] { default_format, channels_in_world_format, server_name_format }, onRedisHandle_InitByServerTypeKeyWithServerName );
registerRequestHandler( (uint)HandlerType.GetByServerKey, new RedisKeyFormat[] { default_format, channels_in_world_format }, onRedisHandle_GetByServerTypeKey );
registerRequestHandler( (uint)HandlerType.GetByServerName, new RedisKeyFormat[] { server_name_format }, onRedisHandle_GetByServerName );
registerRequestHandler( (uint)HandlerType.RemoveByServerKey, new RedisKeyFormat[] { default_format }, onRedisHandle_RemoveByServerTypeKey );
registerRequestHandler( (uint)HandlerType.RemoveByServerName, new RedisKeyFormat[] { server_name_format }, onRedisHandle_RemoveByServerName );
registerRequestHandler( (uint)HandlerType.UpdateByServerName, new RedisKeyFormat[] { server_name_format }, onRedisHandle_UpdateByServerName );
//=========================================================================================
// for Metrics Handler
//=========================================================================================
registerTriggerHandler((uint)TriggerType.ServerMetrics_Init, onTrigger_ServerMetricsInit);
registerTriggerHandler((uint)TriggerType.ServerMetrics_AllGetAndFill, onTrigger_ServerMetricsAllGetAndFill);
registerTriggerHandler((uint)TriggerType.ServerMetrics_ServerTypeGetAndFill, onTrigger_ServerMetricsServerTypeGetAndFill);
registerTriggerHandler((uint)TriggerType.ServerMetrics_ChannelTargetGetAndFill, onTrigger_ServerMetricsChannelTargetGetAndFill);
registerTriggerHandler((uint)TriggerType.ServerMetrics_GetByServerName, onTrigger_ServerMetricsGetByServerName);
registerTriggerHandler((uint)TriggerType.ServerMetrics_ExpiredAllRemove, onTrigger_ServerMetricsExpriredAllRemove);
registerTriggerHandler((uint)TriggerType.ServerMetrics_RemoveByServerName, onTrigger_ServerMetricsRemoveByServerName);
registerTriggerHandler((uint)TriggerType.ServerMetrics_UpdateToCache, onTrigger_ServerMetricsUpdateToCache);
}
//=============================================================================================
// RedisRequest 핸들러 함수
//=============================================================================================
public async Task<IWithResult> onRedisHandle_InitByServerTypeKeyWithServerName(REDIS_KEY[] redisKeys, object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 2
, () => $"Invalid Parameter RedisKey !!! : 2 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");
var redis_key = redisKeys[0];
var server_name_key = redisKeys[1];
ArgumentNullReferenceCheckHelper.throwIfNull(server_name_key, () => $"server_name_key is null !!! - {toBasicString()}");
var redis_connector = getRedisConnector();
var result = new Result();
try
{
var redis_database = redis_connector.getDatabase();
NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");
await redis_database.SetAddAsync(redis_key, server_name_key, CommandFlags.PreferReplica);
return new ResultOnly(result);
}
catch (Exception e)
{
var error_code = ServerErrorCode.RedisException;
var err_msg = $"Exception !!!, Failed to perform in onRedisHandle_InitByServerTypeKey() !!! : errorCode:{error_code}, exception:{e} - {toBasicString()}";
result.setFail(error_code, err_msg);
Log.getLogger().error(err_msg);
return new ResultOnly(result);
}
}
public async Task<IWithResult> onRedisHandle_GetByServerTypeKey(REDIS_KEY[] redisKeys, object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 1
, () => $"Invalid Parameter RedisKey !!! : 1 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");
var redis_key = redisKeys[0];
var redis_connector = getRedisConnector();
var result_value = new ResultValue<List<RedisValue>>(new Result(), new List<RedisValue>());
var result = new Result();
try
{
var redis_database = redis_connector.getDatabase();
NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");
var server_info_keys = await redis_database.SetMembersAsync(redis_key, CommandFlags.PreferReplica);
result_value.ValueOfResult.AddRange(server_info_keys);
return result_value;
}
catch (Exception e)
{
var error_code = ServerErrorCode.RedisException;
var err_msg = $"Exception !!!, Failed to perform !!!, in onRedisHandle_GetByServerTypeKey() : errorCode:{error_code}, exception:{e} - {toBasicString()}";
result.setFail(error_code, err_msg);
Log.getLogger().error(err_msg);
return new ResultOnly(result);
}
}
public async Task<IWithResult> onRedisHandle_GetByServerName(REDIS_KEY[] redisKeys, object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 1
, () => $"Invalid Parameter RedisKey !!! : 1 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");
var redis_key = redisKeys[0];
var redis_connector = getRedisConnector();
var result = new Result();
try
{
var redis_database = redis_connector.getDatabase();
NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");
var redis_result = await redis_database.StringGetAsync(redis_key, CommandFlags.PreferReplica);
if(true == redis_result.IsNull)
{
Log.getLogger().debug($"redis_result.IsNull == true !!!, StringGetAsync(), in onRedisHandle_GetByServerName() : redisKey:{redis_key} - {toBasicString()}");
return new ResultOnly(result);
}
var server_info = JsonConvert.DeserializeObject<ServerInfo>(redis_result.ToString());
if(null == server_info)
{
Log.getLogger().debug($"ServerInfo is Null !!!, JsonConvert.DeserializeObject<ServerInfo>(), in in onRedisHandle_GetByServerName() : redisKey:{redis_key} - {toBasicString()}");
return new ResultOnly(result);
}
return new ResultValue<ServerInfo>(result, server_info);
}
catch (Exception e)
{
var error_code = ServerErrorCode.RedisException;
var err_msg = $"Exception !!!, Failed to perform !!!, in onRedisHandle_GetByServerName() : errorCode:{error_code}, exception:{e} - {toBasicString()}";
result.setFail(error_code, err_msg);
Log.getLogger().error(err_msg);
return new ResultOnly(result);
}
}
public async Task<IWithResult> onRedisHandle_RemoveByServerTypeKey(REDIS_KEY[] redisKeys, object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 1
, () => $"Invalid Parameter RedisKey !!! : 1 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");
var redis_key = redisKeys[0];
var redis_connector = getRedisConnector();
var result = new Result();
try
{
var redis_database = redis_connector.getDatabase();
NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");
var server_info_keys = await redis_database.SetMembersAsync(redis_key, CommandFlags.PreferReplica);
foreach (var data_key in server_info_keys)
{
if (data_key.IsNull == true)
{
continue;
}
var value = await redis_database.StringGetAsync(data_key.ToString(), CommandFlags.PreferReplica);
if (value.IsNull == true)
{
Log.getLogger().debug($"ServerInfo is Null !!! : serverKey:{data_key} - {toBasicString()}");
await redis_database.SetRemoveAsync(redis_key, data_key);
}
}
return new ResultOnly(result);
}
catch (Exception e)
{
var error_code = ServerErrorCode.RedisException;
var err_msg = $"Exception !!!, Failed to perform !!!, in onRedisHandle_RemoveByServerTypeKey() : errorCode:{error_code}, exception:{e} - {toBasicString()}";
result.setFail(error_code, err_msg);
Log.getLogger().error(err_msg);
return new ResultOnly(result);
}
}
public async Task<IWithResult> onRedisHandle_RemoveByServerName(REDIS_KEY[] redisKeys, object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 1
, () => $"Invalid Parameter RedisKey !!! : 1 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");
var redis_key = redisKeys[0];
var redis_connector = getRedisConnector();
var result = new Result();
try
{
var redis_database = redis_connector.getDatabase();
NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");
await redis_database.KeyDeleteAsync(redis_key);
return new ResultOnly(result);
}
catch (Exception e)
{
var error_code = ServerErrorCode.RedisException;
var err_msg = $"Exception !!!, Failed to perform !!!, in onRedisHandle_RemoveByServerName() : errorCode:{error_code}, exception:{e} - {toBasicString()}";
result.setFail(error_code, err_msg);
Log.getLogger().error(err_msg);
return new ResultOnly(result);
}
}
public async Task<IWithResult> onRedisHandle_UpdateByServerName(REDIS_KEY[] redisKeys, object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => redisKeys.Length == 1
, () => $"Invalid Parameter RedisKey !!! : 1 == redisKeyCount:{redisKeys.Length} - {toBasicString()}");
ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 1
, () => $"Invalid Parameter handlerParams !!! : 1 == handlerParamsCount:{handlerParams.Length} - {toBasicString()}");
var redis_key = redisKeys[0];
var server_info = handlerParams[0] as ServerInfo;
NullReferenceCheckHelper.throwIfNull(server_info, () => $"server_info is null !!! - {toBasicString()}");
var redis_connector = getRedisConnector();
var result = new Result();
try
{
var redis_database = redis_connector.getDatabase();
NullReferenceCheckHelper.throwIfNull(redis_database, () => $"redis_database is null !!! - {toBasicString()}");
string json = JsonConvert.SerializeObject(server_info);
await redis_database.StringSetAsync(redis_key, json, TimeSpan.FromMilliseconds(ServerMetricsManager.KEEP_SERVER_UPDATE_INTERVAL_MSEC));
return new ResultOnly(result);
}
catch (Exception e)
{
var error_code = ServerErrorCode.RedisException;
var err_msg = $"Exception !!!, Failed to perform !!!, in onRedisHandle_UpdateByServerName() : errorCode:{error_code}, exception:{e} - {toBasicString()}";
result.setFail(error_code, err_msg);
Log.getLogger().error(err_msg);
return new ResultOnly(result);
}
}
//=============================================================================================
// Metrics Trigger 핸들러 함수
//=============================================================================================
//---------------------------------------------------------------------------------------------
// handlerParams : SERVER_NAME, ServerType, WORLD_META_ID
//---------------------------------------------------------------------------------------------
public async Task<IWithResult> onTrigger_ServerMetricsInit(object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 3
, () => $"Invalid Parameter count !!! : 3 == paramCount:{handlerParams.Length} - {toBasicString()}" );
var server_name = handlerParams[0] as string;
ArgumentNullReferenceCheckHelper.throwIfNull(server_name, () => $"server_name is null !!! - {toBasicString()}");
var server_type = (ServerType)handlerParams[1];
ArgumentNullReferenceCheckHelper.throwIfNull(server_type, () => $"server_type is null !!! - {toBasicString()}");
var world_meta_id = (WORLD_META_ID)Convert.ToUInt32(handlerParams[2]);
ArgumentNullReferenceCheckHelper.throwIfNull(world_meta_id, () => $"world_meta_id is null !!! - {toBasicString()}");
var err_msg = string.Empty;
var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
var handler_type = HandlerType.InitByServerKeyWithServerName;
var redis_key_1 = buildRedisKeyByServerInfo(server_type, world_meta_id);
to_replace_params.Add((uint)redis_key_1.Item1, redis_key_1.Item2);
var redis_key_2 = buildRedisKeyByServerInfo(server_name);
to_replace_params.Add((uint)redis_key_2.Item1, redis_key_2.Item2);
var with_result = await executeRequestHandlerByHandlerType( (uint)handler_type, to_replace_params );
if (with_result.Result.isFail())
{
err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsInit() : {with_result.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
Log.getLogger().error(err_msg);
return with_result;
}
return with_result;
}
//---------------------------------------------------------------------------------------------
// handlerParams : 조회 대상 WORLD_META_ID 목록
//---------------------------------------------------------------------------------------------
public async Task<IWithResult> onTrigger_ServerMetricsAllGetAndFill(object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 1
, () => $"Invalid Parameter count !!! : 1 == paramCount:{handlerParams.Length} - {toBasicString()}");
var result_value = new ResultValue<List<ServerInfo>>(new Result(), new List<ServerInfo>());
var server_typies = new List<ServerType>() { ServerType.Login, ServerType.Channel, ServerType.Indun };
var world_meta_ids = handlerParams[0] as List<WORLD_META_ID>;
NullReferenceCheckHelper.throwIfNull(world_meta_ids, () => $"world_meta_ids is null !!! - {toBasicString()}");
var params_for_redis_requests = new List<(HandlerType, Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>)>();
foreach (var server_type in server_typies)
{
var handler_type = HandlerType.GetByServerKey;
if (ServerType.Channel == server_type)
{
for (var i = 0; i < world_meta_ids.Count; i++)
{
var world_meta_id = (WORLD_META_ID)world_meta_ids[i];
var redis_key = buildRedisKeyByServerInfo(server_type, world_meta_id);
var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);
params_for_redis_requests.Add((handler_type, to_replace_params));
}
}
else
{
var redis_key = buildRedisKeyByServerInfo(server_type);
var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);
params_for_redis_requests.Add((handler_type, to_replace_params));
}
}
return await getAndFillServerInfos(params_for_redis_requests);
}
//---------------------------------------------------------------------------------------------
// handlerParams : 조회 대상 ServerType, WORLD_META_ID
//---------------------------------------------------------------------------------------------
public async Task<IWithResult> onTrigger_ServerMetricsServerTypeGetAndFill(object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 2
, () => $"Invalid Parameter count !!! : 2 == paramCount:{handlerParams.Length} - {toBasicString()}");
var server_type = (ServerType)handlerParams[0];
var world_meta_id = (WORLD_META_ID)Convert.ToUInt32(handlerParams[1]);
var params_for_redis_requests = new List<(HandlerType, Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>)>();
var handler_type = HandlerType.GetByServerKey;
if (ServerType.Channel == server_type)
{
var redis_key = buildRedisKeyByServerInfo(server_type, world_meta_id);
var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);
params_for_redis_requests.Add((handler_type, to_replace_params));
}
else
{
var redis_key = buildRedisKeyByServerInfo(server_type);
var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);
params_for_redis_requests.Add((handler_type, to_replace_params));
}
return await getAndFillServerInfos(params_for_redis_requests);
}
//---------------------------------------------------------------------------------------------
// handlerParams : 조회 대상 WORLD_META_ID, ChannelNo
//---------------------------------------------------------------------------------------------
public async Task<IWithResult> onTrigger_ServerMetricsChannelTargetGetAndFill(object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 2
, () => $"Invalid Parameter count !!! : 2 == paramCount:{handlerParams.Length} - {toBasicString()}");
var world_meta_id = (WORLD_META_ID)Convert.ToUInt32(handlerParams[0]);
var channel_no = Convert.ToUInt32(handlerParams[1]);
var params_for_redis_requests = new List<(HandlerType, Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>)>();
var server_name = ServerBase.ServerHelper.makeGameServerName(ServerType.Channel, (int)world_meta_id, (int)channel_no);
var handler_type = HandlerType.GetByServerName;
var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
var redis_key = buildRedisKeyByServerInfo(server_name);
to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);
var with_result = await executeRequestHandlerByHandlerType((uint)handler_type, to_replace_params);
if (with_result.Result.isFail())
{
var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsChannelTargetGetAndFill() : {with_result.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
Log.getLogger().error(err_msg);
return with_result;
}
if (with_result.isResultOnly())
{
var err_msg = $"isResultOnly() == true, in onTrigger_ServerMetricsChannelTargetGetAndFill(), Not found ServerInfo - handlerType:{handler_type}, {toBasicString()}";
Log.getLogger().debug(err_msg);
return with_result;
}
var result_value_server_info = with_result as ResultValue<ServerInfo>;
NullReferenceCheckHelper.throwIfNull(result_value_server_info, () => $"result_value_server_info is null !!! - handlerType:{handler_type}");
return result_value_server_info;
}
private async Task<IWithResult> getAndFillServerInfos(List<(HandlerType, Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>)> paramForRedisRequests)
{
var result_value = new ResultValue<List<ServerInfo>>(new Result(), new List<ServerInfo>());
var manager = getServerMetricsManager();
var cache_servers = manager.getCacheServers();
long curr_tick = Environment.TickCount64;
foreach (var param in paramForRedisRequests)
{
var handler_type = param.Item1;
var redis_key = param.Item2;
bool to_upsert_cache_server = false;
var server_keys = replaceByHandlerType((uint)handler_type, redis_key);
if (0 >= server_keys.Length)
{
var err_msg = $"Nothing was replaced in the format !!!, in getAndFillServerInfos() : handlerType:{handler_type}, {toBasicString()}";
Log.getLogger().error(err_msg);
continue;
}
var server_key = server_keys[0];
if (false == cache_servers.TryGetValue(server_key, out var found_cache_server))
{
to_upsert_cache_server = true;
found_cache_server = new ServerMetricsCacheRequest.CacheServerKey();
}
else
{
if ((curr_tick - found_cache_server.tick) > 100)
{
to_upsert_cache_server = true;
}
}
var with_result = await executeRequestHandlerByHandlerType((uint)handler_type, redis_key);
if (with_result.Result.isFail())
{
var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in getAndFillServerInfos() : {with_result.Result.toBasicString()} - handlerType:{handler_type}, {toBasicString()}";
Log.getLogger().error(err_msg);
continue;
}
if (with_result.isResultOnly())
{
continue;
}
var with_result_value = with_result as ResultValue<List<RedisValue>>;
NullReferenceCheckHelper.throwIfNull(with_result_value, () => $"with_result_value is null !!! - handlerType:{handler_type}");
if (true == to_upsert_cache_server)
{
found_cache_server.key = server_key;
found_cache_server.tick = curr_tick;
found_cache_server.redisValue.AddRange(with_result_value.ValueOfResult);
cache_servers.AddOrUpdate(server_key, found_cache_server, (key, value) => value = found_cache_server);
}
handler_type = HandlerType.GetByServerName;
foreach (var server_info_key in with_result_value.ValueOfResult)
{
var with_result_redis_read = await executeRequestHandlerByHandlerType((uint)handler_type
, new REDIS_KEY[] { server_info_key.ToString() });
if (with_result_redis_read.Result.isFail())
{
var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in getAndFillServerInfos() : {with_result_redis_read.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
Log.getLogger().error(err_msg);
continue;
}
if (with_result_redis_read.isResultOnly())
{
continue;
}
var result_value_server_info = with_result_redis_read as ResultValue<ServerInfo>;
NullReferenceCheckHelper.throwIfNull(result_value_server_info, () => $"result_value_server_info is null !!! - handlerType:{handler_type}");
if (null == result_value_server_info.ValueOfResult)
{
var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in getAndFillServerInfos() : {with_result_redis_read.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
Log.getLogger().error(err_msg);
continue;
}
result_value.ValueOfResult.Add(result_value_server_info.ValueOfResult);
}
}
return result_value;
}
//---------------------------------------------------------------------------------------------
// handlerParams : SERVER_NAME
//---------------------------------------------------------------------------------------------
public async Task<IWithResult> onTrigger_ServerMetricsGetByServerName(object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length > 0
, () => $"Invalid Parameter count !!! : 0 < paramCount:{handlerParams.Length} - {toBasicString()}" );
var server_name = handlerParams[0] as string;
ArgumentNullReferenceCheckHelper.throwIfNull(server_name, () => $"server_name is null !!! - {toBasicString()}");
var handler_type = HandlerType.GetByServerName;
var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
var redis_key = buildRedisKeyByServerInfo(server_name);
to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);
var with_result = await executeRequestHandlerByHandlerType( (uint)handler_type, to_replace_params );
if (with_result.Result.isFail())
{
var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsGetByServerName() : {with_result.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
Log.getLogger().error(err_msg);
return with_result;
}
if (with_result.isResultOnly())
{
var err_msg = $"isResultOnly() == true, in onTrigger_ServerMetricsGetByServerName(), Not found ServerInfo - handlerType:{handler_type}, {toBasicString()}";
Log.getLogger().debug(err_msg);
return with_result;
}
var result_value_server_info = with_result as ResultValue<ServerInfo>;
NullReferenceCheckHelper.throwIfNull(result_value_server_info, () => $"result_value_server_info is null !!! - handlerType:{handler_type}");
return result_value_server_info;
}
//---------------------------------------------------------------------------------------------
// handlerParams : 체크 대상 WORLD_META_ID 목록
//---------------------------------------------------------------------------------------------
public async Task<IWithResult> onTrigger_ServerMetricsExpriredAllRemove(object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition(() => handlerParams.Length == 1
, () => $"Invalid Parameter count !!! : 1 == paramCount:{handlerParams.Length} - {toBasicString()}");
var result_value = new ResultValue<List<ServerInfo>>(new Result(), new List<ServerInfo>());
var server_typies = new List<ServerType>() { ServerType.Login, ServerType.Channel, ServerType.Indun };
var world_meta_ids = handlerParams[0] as List<WORLD_META_ID>;
NullReferenceCheckHelper.throwIfNull(world_meta_ids, () => $"world_meta_ids is null !!! - {toBasicString()}");
var params_for_redis_requests = new List<(HandlerType, Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>)>();
foreach (var server_type in server_typies)
{
var handler_type = HandlerType.RemoveByServerKey;
if (ServerType.Channel == server_type)
{
for (var i = 0; i < world_meta_ids.Count; i++)
{
var world_meta_id = (WORLD_META_ID)world_meta_ids[i];
var redis_key = buildRedisKeyByServerInfo(server_type, world_meta_id);
var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);
params_for_redis_requests.Add((handler_type, to_replace_params));
}
}
else
{
var redis_key = buildRedisKeyByServerInfo(server_type);
var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);
params_for_redis_requests.Add((handler_type, to_replace_params));
}
}
foreach(var param in params_for_redis_requests)
{
var handler_type = param.Item1;
var redis_key = param.Item2;
var with_result = await executeRequestHandlerByHandlerType( (uint)handler_type, redis_key );
if (with_result.Result.isFail())
{
var err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsExpriredAllRemove() : {with_result.Result.toBasicString()} - handlerType:{handler_type}, {toBasicString()}";
Log.getLogger().error(err_msg);
}
}
return result_value;
}
//---------------------------------------------------------------------------------------------
// handlerParams : 삭제할 SERVER_NAME
//---------------------------------------------------------------------------------------------
public async Task<IWithResult> onTrigger_ServerMetricsRemoveByServerName(object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition(() => handlerParams.Length > 0
, () => $"Invalid Parameter count !!! : 0 < paramCount:{handlerParams.Length} - {toBasicString()}");
var server_name = handlerParams[0] as string;
ArgumentNullReferenceCheckHelper.throwIfNull(server_name, () => $"server_name is null !!! - {toBasicString()}");
var err_msg = string.Empty;
var handler_type = HandlerType.RemoveByServerName;
var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
var redis_key = buildRedisKeyByServerInfo(server_name);
to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);
var with_result = await executeRequestHandlerByHandlerType( (uint)handler_type, to_replace_params );
if (with_result.Result.isFail())
{
err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsRemoveByServerName() : {with_result.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
Log.getLogger().error(err_msg);
return with_result;
}
return with_result;
}
//---------------------------------------------------------------------------------------------
// handlerParams : 갱신 서버 정보
//---------------------------------------------------------------------------------------------
public async Task<IWithResult> onTrigger_ServerMetricsUpdateToCache(object[] handlerParams)
{
ConditionValidCheckHelper.throwIfFalseWithCondition( () => handlerParams.Length == 2
, () => $"Invalid Parameter count !!! : 2 == paramCount:{handlerParams.Length} - {toBasicString()}");
var server_name = handlerParams[0] as string;
ArgumentNullReferenceCheckHelper.throwIfNull(server_name, () => $"server_name is null !!! - {toBasicString()}");
var server_info = handlerParams[1] as ServerInfo;
ArgumentNullReferenceCheckHelper.throwIfNull(server_info, () => $"server_info is null !!! - {toBasicString()}");
var err_msg = string.Empty;
var handler_type = HandlerType.UpdateByServerName;
var to_replace_params = new Dictionary<REDIS_KEY_FORMAT_TYPE, Dictionary<REDIS_KEY_PLACE_HOLDER, REDIS_KEY_REPLACE>>();
var redis_key = buildRedisKeyByServerInfo(server_name);
to_replace_params.Add((uint)redis_key.Item1, redis_key.Item2);
var with_result = await executeRequestHandlerByHandlerType((uint)handler_type, to_replace_params, server_info);
if (with_result.Result.isFail())
{
err_msg = $"Failed to executeRequestHandlerByHandlerType !!!, in onTrigger_ServerMetricsUpdateToCache() : {with_result.Result.toBasicString()}, handlerType:{handler_type} - {toBasicString()}";
Log.getLogger().error(err_msg);
return with_result;
}
return with_result;
}
}