Grpc transport based class (#87)

* Make ClientBase abstract class

* Create GrpcTransport.cs based class like Java SDK

* Fix issue

* fix linter

Author: KirillKurdyukov

src/Ydb.Sdk/src/Driver.cs

@@ -294,23 +294,9 @@ private CallOptions GetCallOptions(RequestSettings settings, bool streaming)
         return options;
     }
 
-    private static StatusCode ConvertStatusCode(Grpc.Core.StatusCode rpcStatusCode)
-    {
-        return rpcStatusCode switch
-        {
-            Grpc.Core.StatusCode.Unavailable => StatusCode.ClientTransportUnavailable,
-            Grpc.Core.StatusCode.DeadlineExceeded => StatusCode.ClientTransportTimeout,
-            Grpc.Core.StatusCode.ResourceExhausted => StatusCode.ClientTransportResourceExhausted,
-            Grpc.Core.StatusCode.Unimplemented => StatusCode.ClientTransportUnimplemented,
-            _ => StatusCode.ClientTransportUnknown
-        };
-    }
-
     private static Status ConvertStatus(Grpc.Core.Status rpcStatus)
     {
-        return new Status(
-            ConvertStatusCode(rpcStatus.StatusCode),
-            new List<Issue> { new(rpcStatus.Detail) });
+        return rpcStatus.ConvertStatus();
     }
 
     internal sealed class UnaryResponse<TResponse>

src/Ydb.Sdk/src/DriverConfig.cs

@@ -6,15 +6,10 @@ namespace Ydb.Sdk;
 public class DriverConfig
 {
     public string Endpoint { get; }
-
     public string Database { get; }
-
     public ICredentialsProvider Credentials { get; }
-
     public X509Certificate? CustomServerCertificate { get; }
-
     public TimeSpan DefaultTransportTimeout { get; }
-
     public TimeSpan DefaultStreamingTransportTimeout { get; }
 
     internal TimeSpan EndpointDiscoveryInterval = TimeSpan.FromMinutes(1);

src/Ydb.Sdk/src/GrpcTransport.cs

@@ -0,0 +1,120 @@
+using Grpc.Core;
+using Grpc.Net.Client;
+using Microsoft.Extensions.Logging;
+
+namespace Ydb.Sdk;
+
+// TODO Experimental [for Driver with fix call options]
+public abstract class GrpcTransport : IDisposable, IAsyncDisposable
+{
+    protected readonly ILogger Logger;
+    protected readonly DriverConfig Config;
+
+    internal GrpcTransport(DriverConfig driverConfig, ILogger logger)
+    {
+        Logger = logger;
+        Config = driverConfig;
+    }
+
+    ~GrpcTransport()
+    {
+        Dispose(false);
+    }
+
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+        return default;
+    }
+
+    protected abstract void Dispose(bool disposing);
+
+    internal async Task<TResponse> UnaryCall<TRequest, TResponse>(
+        Method<TRequest, TResponse> method,
+        RequestSettings settings,
+        TRequest request
+    ) where TRequest : class where TResponse : class
+    {
+        var (endpoint, channel) = GetChannel();
+        var callInvoker = channel.CreateCallInvoker();
+
+        Logger.LogTrace("Unary call, method: {MethodName}, endpoint: {Endpoint}", method.Name, endpoint);
+
+        try
+        {
+            using var call = callInvoker.AsyncUnaryCall(
+                method: method,
+                host: null,
+                options: GetCallOptions(settings, false),
+                request: request
+            );
+
+            return await call.ResponseAsync;
+        }
+        catch (RpcException e)
+        {
+            OnRpcError(endpoint, e);
+            throw new TransportException(e);
+        }
+    }
+
+    protected abstract (string, GrpcChannel) GetChannel();
+
+    protected abstract void OnRpcError(string endpoint, RpcException e);
+
+    private CallOptions GetCallOptions(RequestSettings settings, bool streaming)
+    {
+        var meta = new Grpc.Core.Metadata
+        {
+            { Metadata.RpcDatabaseHeader, Config.Database }
+        };
+
+        var authInfo = Config.Credentials.GetAuthInfo();
+        if (authInfo != null)
+        {
+            meta.Add(Metadata.RpcAuthHeader, authInfo);
+        }
+
+        if (settings.TraceId.Length > 0)
+        {
+            meta.Add(Metadata.RpcTraceIdHeader, settings.TraceId);
+        }
+
+        var transportTimeout = streaming
+            ? Config.DefaultStreamingTransportTimeout
+            : Config.DefaultTransportTimeout;
+
+        if (settings.TransportTimeout != null)
+        {
+            transportTimeout = settings.TransportTimeout.Value;
+        }
+
+        var options = new CallOptions(
+            headers: meta
+        );
+
+        if (transportTimeout != TimeSpan.Zero)
+        {
+            options = options.WithDeadline(DateTime.UtcNow + transportTimeout);
+        }
+
+        return options;
+    }
+}
+
+public class TransportException : Exception
+{
+    internal TransportException(RpcException e) : base($"Transport exception: {e.Message}", e)
+    {
+        Status = e.Status.ConvertStatus();
+    }
+
+    public Status Status { get; }
+}

src/Ydb.Sdk/src/Status.cs

@@ -247,3 +247,21 @@ public StatusUnsuccessfulException(Status status)
 
     public Status Status { get; }
 }
+
+internal static class StatusExtensions
+{
+    internal static Status ConvertStatus(this Grpc.Core.Status rpcStatus)
+    {
+        return new Status(
+            rpcStatus.StatusCode switch
+            {
+                Grpc.Core.StatusCode.Unavailable => StatusCode.ClientTransportUnavailable,
+                Grpc.Core.StatusCode.DeadlineExceeded => StatusCode.ClientTransportTimeout,
+                Grpc.Core.StatusCode.ResourceExhausted => StatusCode.ClientTransportResourceExhausted,
+                Grpc.Core.StatusCode.Unimplemented => StatusCode.ClientTransportUnimplemented,
+                _ => StatusCode.ClientTransportUnknown
+            },
+            new List<Issue> { new(rpcStatus.Detail) }
+        );
+    }
+}