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)); } }