public ThriftClient(
ThriftClientManager clientManager,
Type clientType,
String clientName,
TimeSpan connectTimeout,
TimeSpan receiveTimeout,
TimeSpan readTimeout,
TimeSpan writeTimeout,
EndPoint socksProxy,
int maxFrameSize,
ClientSslConfig sslConfig,
IEnumerable <ThriftClientEventHandler> eventHandlers)
{
Guard.ArgumentNotNull(clientManager, nameof(clientManager));
Guard.ArgumentNotNull(clientType, nameof(clientType));
Guard.ArgumentNotNull(clientName, nameof(clientName));
Guard.ArgumentNotNull(connectTimeout, nameof(connectTimeout));
Guard.ArgumentNotNull(receiveTimeout, nameof(receiveTimeout));
Guard.ArgumentNotNull(readTimeout, nameof(readTimeout));
Guard.ArgumentNotNull(writeTimeout, nameof(writeTimeout));
Guard.ArgumentCondition(maxFrameSize >= 0, "maxFrameSize cannot be negative");
Guard.ArgumentNotNull(eventHandlers, nameof(clientManager));
this._clientManager = clientManager;
this.ClientType = clientType;
this.ClientName = clientName;
this.ConnectTimeout = connectTimeout;
this.ReceiveTimeout = receiveTimeout;
this.ReadTimeout = readTimeout;
this.WriteTimeout = writeTimeout;
this.SocksProxy = socksProxy;
this.MaxFrameSize = maxFrameSize;
this.SslConfig = sslConfig;
this._eventHandlers = eventHandlers;
}
public Task <TChannel> CreateChannelAsync <TChannel>(
INiftyClientConnector <TChannel> connector,
TimeSpan?connectTimeout,
TimeSpan?receiveTimeout,
TimeSpan?readTimeout,
TimeSpan?writeTimeout,
int maxFrameSize,
ClientSslConfig sslConfig = null,
EndPoint socksProxy = null)
where TChannel : INiftyClientChannel
{
this.ThrowIfDisposed();
Guard.ArgumentNotNull(connector, nameof(connector));
var connectFuture = niftyClient.ConnectAsync(
connector,
connectTimeout,
receiveTimeout,
readTimeout,
writeTimeout,
maxFrameSize,
sslConfig,
socksProxy);
return(connectFuture);
}
/// <summary>
/// 导出远程调用的依赖项。
/// </summary>
/// <returns></returns>
public IEnumerable <SmartServiceDescriptor> ExportDependencies(SwiftyOptions swiftyOptions)
{
var thriftServices = this.RawAssembly.ExportedTypes
.Where(t => t.GetTypeInfo().IsInterface&& IsThriftService(t));
Object GetRemoteServiceInstance(IServiceProvider serviceProvider, RemoteServiceAttribute removeAttribute, Type thriftInterface)
{
var clientManager = serviceProvider.GetRequiredService <SwiftyClientManager>();
ClientSslConfig ssl = swiftyOptions.Client.GetSslConfig(removeAttribute.VipAddress);
if (this._options.Client.TryGetDirectAddress(removeAttribute.VipAddress, out string address))
{
return(clientManager.Client.Create(thriftInterface, address, ssl));
}
return(clientManager.Client.Create(thriftInterface, removeAttribute.Version, removeAttribute.VipAddress, ssl));
}
foreach (var thriftService in thriftServices)
{
if (thriftService.TryGetRemoteServiceAttribute(true, out RemoteServiceAttribute attribute))
{
yield return(new SmartServiceDescriptor(thriftService, sp => GetRemoteServiceInstance(sp, attribute, thriftService), ServiceLifetime.Singleton)
{
Options = SmartOptions.TryAppend
});
}
}
}
public ChannelKey(IPEndPoint ipEndPoint, ClientSslConfig clientSslConfig, int connectionTimeout, int receiveTimeout, int writeTimeout, int readTimeout)
{
IpEndPoint = ipEndPoint;
ConnectionTimeout = connectionTimeout;
ReceiveTimeout = receiveTimeout;
WriteTimeout = writeTimeout;
ReadTimeout = readTimeout;
SslConfig = clientSslConfig;
}
//[DebuggerHidden]
private object Call(MethodInfo method, ClientSslConfig sslConfig, Ribbon.Server server, string version, string vipAddress, object[] args)
{
var request = new ThriftyRequest(_swiftyClientOptions.RetryEnabled,
_swiftyClientOptions.RetriesNextServer, _swiftyClientOptions.RetriesSameServer,
_swiftyClientOptions.ReadTimeoutMilliseconds, _swiftyClientOptions.WriteTimeoutMilliseconds,
_swiftyClientOptions.ReceiveTimeoutMilliseconds,
_swiftyClientOptions.ConnectTimeoutMilliseconds, args, method);
var response = RibbonCall(request, sslConfig, server, version, vipAddress);
return(response.Payload);
}
public Task <TClient> CreateClientAsync <TClient>(
String host,
int port,
ThriftClientConfig config = null,
String clientName = null,
ClientSslConfig sslConfig = null,
IEnumerable <ThriftClientEventHandler> eventHandlers = null)
where TClient : class
{
return(this.CreateClientAsync(host, port, typeof(TClient), config, clientName, sslConfig, eventHandlers)
.ContinueWith(t => t.Result as TClient));
}
public Task <TClient> CreateClientAsync <TClient, TChannel>(
INiftyClientConnector <TChannel> connector,
ThriftClientConfig config = null,
String clientName = null,
ClientSslConfig sslConfig = null,
IEnumerable <ThriftClientEventHandler> eventHandlers = null)
where TClient : class
where TChannel : INiftyClientChannel
{
return(this.CreateClientAsync(connector, typeof(TClient), config, clientName, sslConfig, eventHandlers)
.ContinueWith(t => t.Result as TClient));
}
public Task <Object> CreateClientAsync(
String host,
int port,
Type clientType,
ThriftClientConfig config = null,
String clientName = null,
ClientSslConfig sslConfig = null,
IEnumerable <ThriftClientEventHandler> eventHandlers = null)
{
return(this.CreateClientAsync(
new FramedClientConnector(host, port, _loggerFactory),
clientType, config, clientName, sslConfig, eventHandlers));
}
public Task <Object> CreateClientAsync <TChannel>(
INiftyClientConnector <TChannel> connector,
Type clientType,
TimeSpan?connectTimeout,
TimeSpan?receiveTimeout,
TimeSpan?readTimeout,
TimeSpan?writeTimeout,
int maxFrameSize,
string clientName,
ClientSslConfig sslConfig,
IEnumerable <ThriftClientEventHandler> eventHandlers,
EndPoint socksProxy)
where TChannel : INiftyClientChannel
{
this.ThrowIfDisposed();
Guard.ArgumentNotNull(connector, nameof(connector));
Guard.ArgumentNotNull(clientType, nameof(clientType));
eventHandlers = eventHandlers ?? Enumerable.Empty <ThriftClientEventHandler>();
var connectFuture = this.CreateChannelAsync(
connector,
connectTimeout,
receiveTimeout,
readTimeout,
writeTimeout,
maxFrameSize,
sslConfig,
socksProxy);
return(connectFuture.ContinueWith(t =>
{
String name = String.IsNullOrWhiteSpace(clientName) ? DefaultClientName : clientName;
INiftyClientChannel channel = null;
try
{
channel = t.Result;
return this.CreateClient(channel, clientType, name, eventHandlers);
}
catch (AggregateException ex)
{
_logger.LogError(0, ex, $"create clinet channel fault.");
// The channel was created successfully, but client creation failed so the
// channel must be closed now
channel?.CloseAsync();
throw;
}
}));
}
private ThriftyResponse RibbonCall(ThriftyRequest request, ClientSslConfig sslConfig, Ribbon.Server server, string version, string vipAddress)
{
if (server != null)
{
return(Execute(request, server, sslConfig));
}
var command = GetCommand(new LoadBalanceKey(version, vipAddress));
if (command == null)
{
throw new ThriftyException("need config Eureka");
}
return(command.Submit(s =>
{
var result = Execute(request, s, sslConfig);
return Task.FromResult(result);
}).GetAwaiter().GetResult());
}
public Task <Object> CreateClientAsync <TChannel>(
INiftyClientConnector <TChannel> connector,
Type clientType,
ThriftClientConfig config = null,
String clientName = null,
ClientSslConfig sslConfig = null,
IEnumerable <ThriftClientEventHandler> eventHandlers = null)
where TChannel : INiftyClientChannel
{
config = config ?? new ThriftClientConfig();
return(this.CreateClientAsync(connector,
clientType,
config.ConnectTimeout,
config.ReceiveTimeout,
config.ReceiveTimeout,
config.WriteTimeout,
config.MaxFrameSize,
clientName,
sslConfig,
eventHandlers,
null));
}
public Task <TChannel> CreateChannelAsync <TChannel>(INiftyClientConnector <TChannel> connector, ClientSslConfig sslConfig = null)
where TChannel : INiftyClientChannel
{
return(CreateChannelAsync(connector,
DEFAULT_CONNECT_TIMEOUT,
DEFAULT_RECEIVE_TIMEOUT,
DEFAULT_READ_TIMEOUT,
DEFAULT_WRITE_TIMEOUT,
DEFAULT_MAX_FRAME_SIZE,
sslConfig,
this.DefaultSocksProxy));
}
private T InnerCreate <T>(string version, string vipAddress, Ribbon.Server server, ClientSslConfig sslConfig) where T : class
{
this.ThrowIfDisposed();
var type = typeof(T);
if (!type.GetTypeInfo().IsInterface)
{
throw new NotSupportedException($"{type} must be an interface");
}
var proxy = FakeProxy <T> .Create(this, server, version, vipAddress, sslConfig);
return(proxy);
}
private static object CrossCaller(ThriftyClient client, MethodBase info, ClientSslConfig sslConfig,
Ribbon.Server server, string version, string vipAddress, object[] args) =>
client.Call(info as MethodInfo, sslConfig, server, version, vipAddress, args);
public object Create(Type type, string hostAndPort, ClientSslConfig sslConfig = null) => InnerCreate(type, null, null, new Ribbon.Server(hostAndPort), sslConfig);
public object Create(Type type, string version, string vipAddress, ClientSslConfig sslConfig = null) => InnerCreate(type, version, vipAddress, null, sslConfig);
public T Create <T>(string hostAndPort, ClientSslConfig ssl = null) where T : class => InnerCreate <T>(null, null, new Ribbon.Server(hostAndPort), ssl);
public T Create <T>(string version, string vipAddress, ClientSslConfig ssl = null) where T : class => InnerCreate <T>(version, vipAddress, null, ssl);
private object InnerCreate(Type type, string version, string vipAddress, Ribbon.Server server, ClientSslConfig sslConfig)
{
this.ThrowIfDisposed();
if (!type.GetTypeInfo().IsInterface)
{
throw new ThriftyException($"swifty service must be an interface, but '{type}' was not.");
}
return(_proxyCreater.GetOrAdd(type, t =>
{
var fullType = typeof(FakeProxy <>).MakeGenericType(t);
var method = fullType.GetMethod("Create", new[] { typeof(ThriftyClient), typeof(Ribbon.Server), typeof(string), typeof(string), typeof(ClientSslConfig) });
var p1 = Expression.Parameter(typeof(ThriftyClient));
var p2 = Expression.Parameter(typeof(Ribbon.Server));
var p3 = Expression.Parameter(typeof(string));
var p4 = Expression.Parameter(typeof(string));
var p5 = Expression.Parameter(typeof(ClientSslConfig));
var call = Expression.Call(method, p1, p2, p3, p4, p5);
var lambda = Expression.Lambda <Func <ThriftyClient, Ribbon.Server, string, string, ClientSslConfig, object> >(call, p1, p2, p3, p4, p5).Compile();
return lambda;
})(this, server, version, vipAddress, sslConfig));
}
public static T Create(ThriftyClient client, Ribbon.Server server, string version, string vipAddress, ClientSslConfig sslConfig) => Creator(client, sslConfig, server, version, vipAddress);
private ThriftyResponse Execute(ThriftyRequest request, Ribbon.Server server, ClientSslConfig sslConfig)
{
var func = _methodCache.GetOrAdd(request.Method, CreateFunc);
_logger.LogDebug(new EventId(0, "ThriftyClient"), $"use {server}");
var discoveryEnabledServer = server as DiscoveryEnabledServer;
var host = discoveryEnabledServer == null ? server.Host : discoveryEnabledServer.InstanceInfo.IpAddr;
var port = discoveryEnabledServer?.Port ?? server.Port;
var address = string.Compare("localhost", host, StringComparison.OrdinalIgnoreCase) == 0
? IPAddress.Loopback
: IPAddress.Parse(host);
var key = new ChannelKey(new IPEndPoint(address, port), sslConfig,
request.ConnectTimeout, request.ReveiveTimeout, request.WriteTimeout, request.ReadTimeout);
using (var channel = new PooledClientChannel(this._channelPools, key))
{
var proxy = GetStub(request, key, channel);
var result = func(proxy, request.Args);
return(new ThriftyResponse(result, true));
}
}
