[#26] All: Remove V2 from naming

Rename project, namespaces and class names

Signed-off-by: Pavel Gross <p.gross@yadro.com>

src/FrostFS.SDK.Client/Pool/ClientStatusMonitor.cs

@@ -0,0 +1,163 @@
+using System;
+using System.Threading;
+
+using Microsoft.Extensions.Logging;
+
+namespace FrostFS.SDK.Client;
+
+// clientStatusMonitor count error rate and other statistics for connection.
+public class ClientStatusMonitor : IClientStatus
+{
+    private static readonly MethodIndex[] MethodIndexes =
+    [
+        MethodIndex.methodBalanceGet,
+        MethodIndex.methodContainerPut,
+        MethodIndex.methodContainerGet,
+        MethodIndex.methodContainerList,
+        MethodIndex.methodContainerDelete,
+        MethodIndex.methodEndpointInfo,
+        MethodIndex.methodNetworkInfo,
+        MethodIndex.methodNetMapSnapshot,
+        MethodIndex.methodObjectPut,
+        MethodIndex.methodObjectDelete,
+        MethodIndex.methodObjectGet,
+        MethodIndex.methodObjectHead,
+        MethodIndex.methodObjectRange,
+        MethodIndex.methodObjectPatch,
+        MethodIndex.methodSessionCreate,
+        MethodIndex.methodAPEManagerAddChain,
+        MethodIndex.methodAPEManagerRemoveChain,
+        MethodIndex.methodAPEManagerListChains
+    ];
+
+    public static string GetMethodName(MethodIndex index)
+    {
+        return index switch
+        {
+            MethodIndex.methodBalanceGet => "BalanceGet",
+            MethodIndex.methodContainerPut => "ContainerPut",
+            MethodIndex.methodContainerGet => "ContainerGet",
+            MethodIndex.methodContainerList => "ContainerList",
+            MethodIndex.methodContainerDelete => "ContainerDelete",
+            MethodIndex.methodEndpointInfo => "EndpointInfo",
+            MethodIndex.methodNetworkInfo => "NetworkInfo",
+            MethodIndex.methodNetMapSnapshot => "NetMapSnapshot",
+            MethodIndex.methodObjectPut => "ObjectPut",
+            MethodIndex.methodObjectDelete => "ObjectDelete",
+            MethodIndex.methodObjectGet => "ObjectGet",
+            MethodIndex.methodObjectHead => "ObjectHead",
+            MethodIndex.methodObjectRange => "ObjectRange",
+            MethodIndex.methodObjectPatch => "ObjectPatch",
+            MethodIndex.methodSessionCreate => "SessionCreate",
+            MethodIndex.methodAPEManagerAddChain => "APEManagerAddChain",
+            MethodIndex.methodAPEManagerRemoveChain => "APEManagerRemoveChain",
+            MethodIndex.methodAPEManagerListChains => "APEManagerListChains",
+            _ => throw new ArgumentException("Unknown method", nameof(index)),
+        };
+    }
+
+    private readonly object _lock = new();
+
+    private readonly ILogger? logger;
+    private int healthy;
+
+    public ClientStatusMonitor(ILogger? logger, string address)
+    {
+        this.logger = logger;
+        healthy = (int)HealthyStatus.Healthy;
+
+        Address = address;
+        Methods = new MethodStatus[MethodIndexes.Length];
+
+        for (int i = 0; i < MethodIndexes.Length; i++)
+        {
+            Methods[i] = new MethodStatus(GetMethodName(MethodIndexes[i]));
+        }
+    }
+
+    public string Address { get; }
+
+    internal uint ErrorThreshold { get; set; }
+
+    public uint CurrentErrorCount { get; set; }
+
+    public ulong OverallErrorCount { get; set; }
+
+    public MethodStatus[] Methods { get; private set; }
+
+    public bool IsHealthy()
+    {
+        var res = Interlocked.CompareExchange(ref healthy, -1, -1) == (int)HealthyStatus.Healthy;
+        return res;
+    }
+
+    public bool IsDialed()
+    {
+        return Interlocked.CompareExchange(ref healthy, -1, -1) != (int)HealthyStatus.UnhealthyOnDial;
+    }
+
+    public void SetHealthy()
+    {
+        Interlocked.Exchange(ref healthy, (int)HealthyStatus.Healthy);
+    }
+    public void SetUnhealthy()
+    {
+        Interlocked.Exchange(ref healthy, (int)HealthyStatus.UnhealthyOnRequest);
+    }
+
+    public void SetUnhealthyOnDial()
+    {
+        Interlocked.Exchange(ref healthy, (int)HealthyStatus.UnhealthyOnDial);
+    }
+
+    public void IncErrorRate()
+    {
+        bool thresholdReached;
+        lock (_lock)
+        {
+            CurrentErrorCount++;
+            OverallErrorCount++;
+
+            thresholdReached = CurrentErrorCount >= ErrorThreshold;
+
+            if (thresholdReached)
+            {
+                SetUnhealthy();
+                CurrentErrorCount = 0;
+            }
+        }
+
+        if (thresholdReached && logger != null)
+        {
+            FrostFsMessages.ErrorЕhresholdReached(logger, Address, ErrorThreshold);
+        }
+    }
+
+    public uint GetCurrentErrorRate()
+    {
+        lock (_lock)
+        {
+            return CurrentErrorCount;
+        }
+    }
+
+    public ulong GetOverallErrorRate()
+    {
+        lock (_lock)
+        {
+            return OverallErrorCount;
+        }
+    }
+
+    public StatusSnapshot[] MethodsStatus()
+    {
+        var result = new StatusSnapshot[Methods.Length];
+
+        for (int i = 0; i < result.Length; i++)
+        {
+            result[i] = Methods[i].Snapshot!;
+        }
+
+        return result;
+    }
+}