frostfs-sdk-csharp/src/FrostFS.SDK.Client/Services/NetmapServiceProvider.cs

using System;
using System.Threading.Tasks;

using FrostFS.Netmap;

using static FrostFS.Netmap.NetworkConfig.Types;

namespace FrostFS.SDK.Client;

internal sealed class NetmapServiceProvider : ContextAccessor
{
    private readonly NetmapService.NetmapServiceClient netmapServiceClient;

    internal NetmapServiceProvider(NetmapService.NetmapServiceClient netmapServiceClient, ClientContext context)
        : base(context)
    {
        this.netmapServiceClient = netmapServiceClient;
    }

    internal async Task<NetworkSettings> GetNetworkSettingsAsync(CallContext ctx)
    {
        if (ClientContext.NetworkSettings != null)
            return ClientContext.NetworkSettings;

        var response = await GetNetworkInfoAsync(ctx).ConfigureAwait(false);

        var settings = new NetworkSettings();

        var info = response.Body.NetworkInfo;

        settings.Epoch = info.CurrentEpoch;
        settings.MagicNumber = info.MagicNumber;
        settings.MsPerBlock = info.MsPerBlock;

        foreach (var param in info.NetworkConfig.Parameters)
        {
            SetNetworksParam(param, settings);
        }

        ClientContext.NetworkSettings = settings;

        return settings;
    }

    internal async Task<FrostFsNodeInfo> GetLocalNodeInfoAsync(CallContext ctx)
    {
        var request = new LocalNodeInfoRequest
        {
            Body = new LocalNodeInfoRequest.Types.Body { }
        };

        request.AddMetaHeader([]);
        request.Sign(ClientContext.Key.ECDsaKey);

        var response = await netmapServiceClient.LocalNodeInfoAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);

        Verifier.CheckResponse(response);

        return response.Body.ToModel();
    }

    internal async Task<NetworkInfoResponse> GetNetworkInfoAsync(CallContext ctx)
    {
        var request = new NetworkInfoRequest();

        request.AddMetaHeader([]);
        request.Sign(ClientContext.Key.ECDsaKey);

        var response = await netmapServiceClient.NetworkInfoAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken)
            .ConfigureAwait(false);

        Verifier.CheckResponse(response);

        return response;
    }

    internal async Task<FrostFsNetmapSnapshot> GetNetmapSnapshotAsync(CallContext ctx)
    {
        var request = new NetmapSnapshotRequest();

        request.AddMetaHeader([]);
        request.Sign(ClientContext.Key.ECDsaKey);

        var response = await netmapServiceClient.NetmapSnapshotAsync(request, null, ctx.GetDeadline(), ctx.CancellationToken);

        Verifier.CheckResponse(response);

        return response.ToModel();
    }

    private static bool GetBoolValue(ReadOnlySpan<byte> bytes)
    {
        for (int i = bytes.Length - 1; i >= 0; i--)
            if (bytes[i] != 0)
                return true;

        return false;
    }

    private static ulong GetLongValue(ReadOnlySpan<byte> bytes)
    {
        ulong val = 0;
        for (var i = bytes.Length - 1; i >= 0; i--)
            val = (val << 8) + bytes[i];

        return val;
    }

    private static void SetNetworksParam(Parameter param, NetworkSettings settings)
    {
        var key = param.Key.ToStringUtf8();

        var valueBytes = param.Value.Span;
        switch (key)
        {
            case "AuditFee":
                settings.AuditFee = GetLongValue(valueBytes);
                break;
            case "BasicIncomeRate":
                settings.BasicIncomeRate = GetLongValue(valueBytes);
                break;
            case "ContainerFee":
                settings.ContainerFee = GetLongValue(valueBytes);
                break;
            case "ContainerAliasFee":
                settings.ContainerAliasFee = GetLongValue(valueBytes);
                break;
            case "EpochDuration":
                settings.EpochDuration = GetLongValue(valueBytes);
                break;
            case "InnerRingCandidateFee":
                settings.InnerRingCandidateFee = GetLongValue(valueBytes);
                break;
            case "MaxECDataCount":
                settings.MaxECDataCount = GetLongValue(valueBytes);
                break;
            case "MaxECParityCount":
                settings.MaxECParityCount = GetLongValue(valueBytes);
                break;
            case "MaxObjectSize":
                settings.MaxObjectSize = GetLongValue(valueBytes);
                break;
            case "WithdrawFee":
                settings.WithdrawFee = GetLongValue(valueBytes);
                break;
            case "HomomorphicHashingDisabled":
                settings.HomomorphicHashingDisabled = GetBoolValue(valueBytes);
                break;
            case "MaintenanceModeAllowed":
                settings.MaintenanceModeAllowed = GetBoolValue(valueBytes);
                break;
            default:
                settings.UnnamedSettings.Add(key, valueBytes.ToArray());
                break;
        }
    }
}