.Net Rpc服务调用记录2

在客户端，通过IProxy作为调用的总入口，方法签名如下：

Task<TResult> InvokeAsync<TResult>(string serviceType,string serviceMethod,params object[] parameters);

（此处没有生成服务的代理，通过字符串指定要调用的类型，方法）；具体实现如下：

public class Proxy : IProxy
{
private IServiceFinder _finder;
private IRemoteServiceInvoker _invoker;
public ITracer Tracer { get; set; }

public Proxy(
IServiceFinder finder,
IRemoteServiceInvoker invoker)
{
_finder = finder;
_invoker = invoker;
Tracer = EmptyTracer.Instance;
}

public async Task<TResult> InvokeAsync<TResult>(string serviceType, string serviceMethod, params object[] parameters)
{
ContractUtility.CheckEmptyOrNull(serviceType, nameof(serviceType));
ContractUtility.CheckEmptyOrNull(serviceMethod, nameof(serviceMethod));

Tracer.Trace($"Begin to finds server address by type:{serviceType},method:{serviceMethod}");
var address = await _finder.FindAysnc(serviceType,serviceMethod);
ContractUtility.CheckNull(address, nameof(address));

var request = new RequestMessage {
Id = Guid.NewGuid().ToString("N"),
ServiceType = serviceType,
ServiceMethod = serviceMethod,
Parameters = parameters
};

var instance = await _invoker.InvokeAsync(address, request);
return ConvertTo<TResult>(instance);
}

private TResult ConvertTo<TResult>(object instance) {
if (instance == null) {
return default(TResult);
}
return (TResult)instance;
}
}

其中，IServiceFinder 内部从IServiceRouteManager中得到可用的服务地址；IServiceRouteManager 提供了两种实现 1.文件 2.Consul；获得地址后，调用IServiceRouteSelector进行地址筛选，提供了两种简单筛选1.随机 2.轮询。具体实现如下：

 public class DefaultServiceFinder : IServiceFinder
    {
        private IServiceRouteManager _serviceRouteManager;
        private IServiceRouteSelector _serviceRouteSelector;
        public DefaultServiceFinder(
            IServiceRouteManager serviceRouteManager,
            IServiceRouteSelector serviceRouteSelector) {
            _serviceRouteManager = serviceRouteManager;
            _serviceRouteSelector = serviceRouteSelector;
        }
        public async Task<IPAddressModel> FindAysnc(string serviceType, string serviceMethod)
        {
            var route = await _serviceRouteManager.GetRouteAsync(serviceType,serviceMethod);      
            return await _serviceRouteSelector.SelectAsync(route);            
        }
    }

public class ConsulServiceRouteManager : ServiceRouteManagerBase
    {
        private ConsulClient _client;

        public ConsulServiceRouteManager(Action<ConsulRuntimeConfiguration> config) {

            var runtimeConfig = new ConsulRuntimeConfiguration();
            if (config != null){
                config(runtimeConfig);
            }
            _client = new ConsulClient(c=> {
                c.Address = new Uri(runtimeConfig.Address);
                c.Token = runtimeConfig.Token;
                c.Datacenter = runtimeConfig.DataCenter;
            } );
        }

        public override Task ClearAsync()
        {
            return Task.FromResult(0);
        }

        public override async Task<IEnumerable<ServiceRoute>> GetRouteAsync()
        {
            var response = await _client.Agent.Services();
            if (response.StatusCode == System.Net.HttpStatusCode.OK) {
                var serviceRoutes = response.Response.ToServiceRoutes();
                return serviceRoutes.MergeAddress();
            }
            throw new Exception($"Fail to get services from consul server {_client.Config.Address.ToString()}");
        }

        public override async Task SetRouteAsync(IEnumerable<ServiceRoute> serviceRoutes)
        {
            ContractUtility.CheckNullOrLength0(serviceRoutes, nameof(serviceRoutes));

            var consulServices = serviceRoutes.SelectMany(sr => sr.ToConsulServiceDefinition());

            foreach (var serviceDefinition in consulServices) {
                await _client.Agent.ServiceRegister(serviceDefinition);
            }
        }
    }

获取地址后，将地址和RequestMessage交给IRemoteServiceInvoker，进行发送，实现如下；这里面关键是在发送前，通过TaskCompletionSource设置回调钩子：

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using GP.RPC.Logging.Trace;
using GP.RPC.Message;
using GP.RPC.Route.Model;
using GP.RPC.Transport.Receiver;
using GP.RPC.Transport.Sender;
using GP.RPC.Utilities;

namespace GP.RPC.Proxy.ServiceInvoker
{
    public class RemoteServiceInvoker : IRemoteServiceInvoker
    {
        private IMessageSender _sender;
        private IMessageReceiver _receiver;
       
        private ConcurrentDictionary<string, TaskCompletionSource<object>> _innerCachedTaskHook;
        public RemoteServiceInvoker(IMessageSender sender,
            IMessageReceiver receiver)
        {
            _innerCachedTaskHook = new ConcurrentDictionary<string, TaskCompletionSource<object>>();
            _sender = sender;
            _receiver = receiver;
            _receiver.Received += Message_Received;
            _sender.SetReceiverHook(_receiver);
            Tracer = EmptyTracer.Instance;
        }
        public ITracer Tracer { get; set; }
        private Task Message_Received(object message)
        {
            var response = message as ResponseMessage;
            if (message!=null) {

                TaskCompletionSource<object> temp;
                if (_innerCachedTaskHook.TryGetValue(response.RequestId,out temp)) {
                    if (response.Success)
                    {
                        temp.SetResult(response.Result);
                    }
                    else {
                        temp.SetException(new Exception(response.Error));
                    }
                }
            }
            return Task.FromResult(0);
        }

        public async Task<object> InvokeAsync(IPAddressModel address, RequestMessage request)
        {
            var result = RegisterTaskHook(request.Id);
            try
            {
                Tracer.Trace($"Prapre to send to request,host is {address.ToString()}");
                Tracer.Trace($"request message is {request.ToJson()}");
                await _sender.SendAsync(address, request);             
                return await result;
            }            
            finally
            {
                Tracer.Trace($"Remove hook for{request.Id} ");
                TaskCompletionSource<object> temp;
                if (_innerCachedTaskHook.TryRemove(request.Id, out temp))
                {
                    if (!temp.Task.IsCompleted)
                    {
                        Tracer.Trace($"Invoke timeout error for {request.Id} manually");
                        temp.SetException(new TimeoutException("Timeout to receive message from server"));
                    }
                }
            }           
        }

        private Task<object> RegisterTaskHook(string requestId) {

            Tracer.Trace($"Register hook for {requestId}");
            var taskHook = new TaskCompletionSource<object>();                
            _innerCachedTaskHook.TryAdd(requestId, taskHook);
            return taskHook.Task;
        }

    }
}

通过IMessageSender发送消息，底层的通信使用DotNetty实现，因此通信Channel的实现如下：

public class NettyClientMessageSender : IMessageSender
    {
        private Bootstrap bootstrap;
        private MultithreadEventLoopGroup worker;
      
        private ConcurrentDictionary<string, Lazy<IChannel>> _innerCachedChannel = new ConcurrentDictionary<string, Lazy<IChannel>>(); 
       
        public NettyClientMessageSender() {
            Tracer = EmptyTracer.Instance;
            Initialize();
        }

        public ITracer Tracer {
            get;set;
        }
        public void Initialize() {
            Tracer.Trace("Begin to initialize the client sender");
            bootstrap = new Bootstrap();
            worker = new MultithreadEventLoopGroup();
            bootstrap
                  .Group(worker)
                  .Channel<TcpSocketChannel>()
                  .Option(ChannelOption.TcpNodelay, true)
                  .Handler(new ActionChannelInitializer<ISocketChannel>(channel =>
                  {
                      IChannelPipeline pipeline = channel.Pipeline;
                      var handler = new NettyClientHandler();
                      handler.AsyncClientReceiverHook = this.afterSendingHook;
                      pipeline.AddLast(new LengthFieldPrepender(4));
                      pipeline.AddLast(new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4));
                      pipeline.AddLast(IocManager.Instance.Resolve<NettyMessageEncoderAdapter>(),
                                       IocManager.Instance.Resolve<NettyMessageDecoderAdapter>(), handler);                     
                  }));
        }

        public async Task SendAsync(IPAddressModel iPAddress, object message)
        {
            Tracer.Trace("Begin to get the client channel");
            IChannel channel = null; //await bootstrap.ConnectAsync(iPAddress.ToEndPoint()); //
            channel =  _innerCachedChannel.GetOrAdd(iPAddress.ToString(), new Lazy<IChannel>(() => bootstrap.ConnectAsync(iPAddress.ToEndPoint()).Result)).Value;
            if (!channel.Open) {
                Tracer.Trace("Channel is not open");
            }
            await channel.WriteAndFlushAsync(message);
        }

        private Func<object, Task> afterSendingHook;

        public void SetReceiverHook(IMessageReceiver receiver)
        {
            ContractUtility.CheckNull(receiver,nameof(receiver));
            this.afterSendingHook += receiver.OnReceived;
        }
    }

编码默认使用了MessagePack，可通过扩展IBinarySerializer，扩展为其他编码方式。

 

以上是整个客户端关键代码部分的分析。后续会继续服务端的代码分析。