caliverse_server/BrokerApiCore/BrokerServerLogic.cs

using Microsoft.Extensions.Configuration;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;

using ServerCore;

using MODULE_ID = System.UInt32;
using ServerMetricsHelper = ServerBase.ServerMetricsHelper;

namespace BrokerApiCore;

public class BrokerServerLogic : ServerLogicBase, IWithPacketNamespaceVerifier, IWithConfiguration,
	IWithServerMetrics, IWithLogActor
{
	private readonly string m_server_config_path = "./";

	public BrokerServerLogic(ServerConfig serverConfig) : base(serverConfig)
	{
	}

	public Action OnServerStart { get; set; }

	public Result mergeConfiguration(IConfiguration configuration)
	{
		var result = new Result();
		var key_options = configuration;

		// var port = ushort.Parse(key_options["port"] ?? "0");
		var config_file = key_options["config"];

		var server_config = getServerConfig();
		server_config.setConfigFilePath($"{m_server_config_path + ServerConfig.ConfigDirectory + "/" + config_file}");
		return result;
	}

	protected override string onGetDumpFilename()
	{
		return getServerName() + "_" + getServerConfig().getAppParamPort();
	}

	public override async Task<Result> onInit()
	{
		var result = new Result();
		var err_msg = string.Empty;

		var businesslog_refresh_date = MetaHelper.GameConfigMeta.BusinessLogRefreshTime;
		DailyTimeEventManager.Instance.tryAddTask("BrokerBusinessLogRefresh", businesslog_refresh_date, onBusinessLogRefresh);

		result = await base.onInit();
		if (result.isFail())
		{
			err_msg = $"Failed to onInit() !!! : {result.toBasicString()}";
			Log.getLogger().error(err_msg);
			return result;
		}

		return result;
	}

	// 비즈니스 로그가 일일 아카이빙 되도록 강제로 매일 로그를 남긴다.
	private async Task onBusinessLogRefresh()
	{
		await Task.CompletedTask;

		var log_invokers = new List<ILogInvoker>(1);
		var empty_business_refresh_with_log_actor = new EmptyBusinessWithLogActor();
		DailyRefreshBusinessLog log = new();
		log_invokers.Add(log);
		BusinessLogger.collectLogs(new LogActionEx(LogActionType.TestBusinessLog),
			empty_business_refresh_with_log_actor, log_invokers);
		Log.getLogger().info("Broker EmptyBusinessLog write");
	}


	protected override Result onCreateServerName()
	{
		var result = new Result();
		var err_msg = string.Empty;

		var server_type_name = getServerType();
		var server_type = server_type_name.toServerType();
		if (false == server_type.isValidServerType())
		{
			err_msg = $"ServerType invalid !!! : {server_type.ToString()}";
			result.setFail(ServerErrorCode.ServerTypeInvalid, err_msg);
			return result;
		}

		var server_config = getServerConfig();
		var listen_port = server_config.toClientListenPort();
		if (listen_port <= 0)
		{
			err_msg =
				$"Client listen port invalid !!! : appParamPort:{listen_port}, configListenPort:{server_config.ClientListenPort} - {server_type.ToString()}";
			result.setFail(ServerErrorCode.ClientListenPortInvalid, err_msg);
			return result;
		}

		base.setServerName(server_type.toServerName(server_config.toClientListenIP(), listen_port, 0, 0));
		return result;
	}

	protected override Result onLoadMetaDatas()
	{
		return ServerCommon.ServerLogicHelper.loadMetaDatas(this);
	}

	protected override async Task<Result> onRegisterModuleAll()
	{
		var result = new Result();

		var config = getServerConfig();
		var load_config_info = config.getLoadedConfig();
		NullReferenceCheckHelper.throwIfNull(load_config_info,
			() => $"load_config_info is null !!! - {toBasicString()}");

		{
			result = await tryCreateAndRegisterModule(() =>
			{
				var config_param = new DynamoDbClient.ConfigParam();
				result = config_param.tryReadFromJsonOrDefault(load_config_info);
				if (result.isFail())
				{
					return (null, result);
				}

				var module_context = new ModuleContext((MODULE_ID)ModuleId.DynamoDbConnector
					, 0, 0, config_param);
				var created_module = new DynamoDbClient(module_context);
				return (created_module, result);
			});
		}
		return result;
	}

	public override async Task<Result> onCreateTickerAll()
	{
		return await Task.FromResult(new Result());
	}

	protected override async Task<Result> onStartServer()
	{
		var result = await base.onStartServer();
		OnServerStart?.Invoke();
		return result;
	}

	public ILogActor toLogActor()
	{
		var log_info = new LogicActorLog();
		log_info.initLogInfo(
			this.getServerConfig().getRegionId()
			, this.getServerConfig().getWorldId()
			, this.getServerType().toServerType()
			, this.getServerName()
		);
		return log_info;
	}

	// public string toBasicString()
	// {
	// 	return $"{m_server_name}({m_server_type})";
	// }

	// public string getServerType()
	// {
	// 	return m_server_type.ToString();
	// }

	// public string getServerName()
	// {
	// 	return m_server_name;
	// }
	public bool isValidPacketNamespace(string toCheckNamespace, IPacketCommand packetCommand)
	{
		return true;
	}

	public Task<Result> setupServerMetrics()
	{
		return Task.FromResult(new Result());
	}

	public bool isSetupCompleted()
	{
		return ServerMetricsHelper.isSetupCompleted(this);
	}

	public ServerMetricsCacheRequest getServerMetricsCacheRequest()
	{
		return ServerBase.ServerMetricsHelper.getServerMetricsCacheRequest(this);
	}

	public Task<Result> syncServerInfoToCache()
	{
		return Task.FromResult(new Result());
	}

}