caliverse_server/ServerCommon/Cache/PartyServerCacheRequest.cs

using StackExchange.Redis;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;


using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;



namespace ServerCommon;


public class PartyServerCache : CacheBase
{
    public List<string> PartyServers { get; set; } = new();
    
    public string toBasicString()
    {
        return $"PartyCache: PartyServers:{PartyServers}";
    }
}

public class PartyServerCacheRequest : RedisRequestSharedBase
{
    // in
    private readonly string m_party_guid;
    
    // out
    private PartyServerCache? m_party_server_cache_nullable { get; set; }

    public PartyServerCacheRequest(string party_guid, RedisConnector redisConnector) : base(party_guid, redisConnector)
    {
        m_party_guid = party_guid;
    }
    
    protected override string onMakeKey() => $"party:{m_party_guid}:servers";
    public override string toBasicString() => $"LoginCache: In:PartyGuid:{m_party_guid}, Out:{m_party_server_cache_nullable?.toBasicString()}";
    
    public PartyServerCache? getPartyServerCache() => m_party_server_cache_nullable;

    public async Task<Result> keepPartyServerCache()
    {
        var result = new Result();
        string err_msg;

        try
        {
            result = await onPrepareRequest();
            if (result.isFail()) return result;

            var database = getDatabase();
            ArgumentNullException.ThrowIfNull(database);

            var redis_value = await database.KeyExpireAsync(getKey(), TimeSpan.FromMilliseconds(Constant.KEEP_PARTY_TIME));
            if (false == redis_value)
            {
                err_msg = $"Failed to set expire PartyServerCache in Redis !!! : Key:{getKey()} - {nameof(keepPartyServerCache)}";
                result.setFail(ServerErrorCode.RedisGlobalPartyServerCacheWriteFailed, err_msg);
                Log.getLogger().error(err_msg);
            }
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.TryCatchException;
            err_msg = $"Failed to set expire PartyServerCache from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(keepPartyServerCache)}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);
        }

        return result;
    }
    
    public async Task<Result> fetchPartyServerCache()
    {
        var result = new Result();
        string err_msg;

        try
        {
            result = await onPrepareRequest();
            if (result.isFail()) return result;

            var database = getDatabase();
            ArgumentNullException.ThrowIfNull(database);

            var redis_value = await database.ListRangeAsync(getKey());
            
            m_party_server_cache_nullable ??= new PartyServerCache();
            m_party_server_cache_nullable.PartyServers.Clear();
            m_party_server_cache_nullable.PartyServers.AddRange(redis_value.Select(x => x.ToString()));
            
            return result;
            
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.TryCatchException;
            err_msg = $"Failed to get PartyServerCache from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(fetchPartyServerCache)}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);
        }

        return result;
    }

    public async Task<Result> deletePartyServerCache(string delete_server)
    {
        var result = new Result();

        try
        {
            result = await onPrepareRequest();
            if (result.isFail()) return result;

            m_party_server_cache_nullable = null;
            
            var database = getDatabase();
            ArgumentNullException.ThrowIfNull(database);

            _ = await database.ListRemoveAsync(getKey(), delete_server, 1, CommandFlags.FireAndForget);
            return result;
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.TryCatchException;
            var err_msg = $"Failed to delete party server from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(deleteAllPartyServerCache)}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);
        }

        return result;
    }

    public async Task<Result> deleteAllPartyServerCache()
    {
        var result = new Result();

        try
        {
            result = await onPrepareRequest();
            if (result.isFail()) return result;

            m_party_server_cache_nullable = null;
            
            var database = getDatabase();
            ArgumentNullException.ThrowIfNull(database);

            _ = await database.KeyDeleteAsync(getKey(), CommandFlags.FireAndForget);
            return result;
            
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.TryCatchException;
            var err_msg = $"Failed to delete party server from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(deleteAllPartyServerCache)}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);
        }

        return result;
    }
    
    public async Task<Result> addPartyServerCache(string server_name)
    {
        var result = new Result();
        string err_msg;

        try
        {
            result = await onPrepareRequest();
            if (result.isFail()) return result;

            var database = getDatabase();
            ArgumentNullException.ThrowIfNull(database);

            if (!await checkPartyServerCache(server_name))
            {
                var redis_value = await database.ListRightPushAsync(getKey(), new RedisValue(server_name));   
            }
            
            m_party_server_cache_nullable ??= new PartyServerCache();
            if (!m_party_server_cache_nullable.PartyServers.Contains(server_name))
            {
                m_party_server_cache_nullable.PartyServers.Add(server_name);   
            }

            result = await keepPartyServerCache();
            
            return result;
            
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.TryCatchException;
            err_msg = $"Failed to add party server from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(addPartyServerCache)}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);
        }

        return result;
    }

    private async Task<bool> checkPartyServerCache(string server_name)
    {
        var result = new Result();
        
        try
        {
            result = await onPrepareRequest();
            if (result.isFail()) return false;

            var database = getDatabase();
            ArgumentNullException.ThrowIfNull(database);

            var redis_value = await database.ListPositionAsync(getKey(), new RedisValue(server_name));
            if (redis_value >= 0) return true;
        }
        catch (Exception e)
        {
            var error_code = ServerErrorCode.TryCatchException;
            var err_msg = $"Failed to add party server from Redis !!! : : errorCode{error_code}, errMsg:{e.Message} - {nameof(addPartyServerCache)}";
            result.setFail(error_code, err_msg);
            Log.getLogger().error(err_msg);
        }

        return false;
    }

}