private static Tuple <Protocol, TProtocol> GetProtocol(string[] args, TClientTransport transport) { var protocol = args.FirstOrDefault(x => x.StartsWith("-pr"))?.Split(':')?[1]; Protocol selectedProtocol; if (Enum.TryParse(protocol, true, out selectedProtocol)) { switch (selectedProtocol) { case Protocol.Binary: return(new Tuple <Protocol, TProtocol>(selectedProtocol, new TBinaryProtocol(transport))); case Protocol.Compact: return(new Tuple <Protocol, TProtocol>(selectedProtocol, new TCompactProtocol(transport))); case Protocol.Json: return(new Tuple <Protocol, TProtocol>(selectedProtocol, new TJsonProtocol(transport))); case Protocol.Multiplexed: return(new Tuple <Protocol, TProtocol>(selectedProtocol, new TBinaryProtocol(transport))); } } return(new Tuple <Protocol, TProtocol>(selectedProtocol, new TBinaryProtocol(transport))); }
private static Tuple <Protocol, TProtocol> GetProtocol(string[] args, TClientTransport transport) { var protocol = args.FirstOrDefault(x => x.StartsWith("-p"))?.Split(':')?[1]; Protocol selectedProtocol; if (Enum.TryParse(protocol, true, out selectedProtocol)) { switch (selectedProtocol) { case Protocol.Binary: return(new Tuple <Protocol, TProtocol>(selectedProtocol, new TBinaryProtocol(transport))); case Protocol.Compact: return(new Tuple <Protocol, TProtocol>(selectedProtocol, new TCompactProtocol(transport))); case Protocol.Json: return(new Tuple <Protocol, TProtocol>(selectedProtocol, new TJsonProtocol(transport))); case Protocol.Multiplexed: // it returns BinaryProtocol to avoid making wrapped protocol as public in TProtocolDecorator (in RunClientAsync it will be wrapped into Multiplexed protocol) return(new Tuple <Protocol, TProtocol>(selectedProtocol, new TBinaryProtocol(transport))); } } return(new Tuple <Protocol, TProtocol>(selectedProtocol, new TBinaryProtocol(transport))); }
/// <summary> /// TJsonProtocol Constructor /// </summary> public TJsonProtocol(TClientTransport trans) : base(trans) { //throw new NotImplementedException("TJsonProtocol is not fully ready for usage"); Context = new JsonBaseContext(this); Reader = new LookaheadReader(this); }
public HbaseRWTest() { _clientTransport = new TSocketClientTransport(IPAddress.Loopback, 9090); TProtocol protocol = new TBinaryProtocol(_clientTransport); _client = new Hbase.Client(protocol); _hbaseHelper = new HbaseHelper(); _HbaseParser = new HbaseParser(); }
//TODO: should support only specified input transport? public TBufferedClientTransport(TClientTransport transport, int bufSize = 1024) { if (bufSize <= 0) { throw new ArgumentOutOfRangeException(nameof(bufSize), "Buffer size must be a positive number."); } _transport = transport ?? throw new ArgumentNullException(nameof(transport)); _bufSize = bufSize; }
protected override async Task <TClientTransport> AcceptImplementationAsync(CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(await Task.FromCanceled <TClientTransport>(cancellationToken)); } if (_server == null) { throw new TTransportException(TTransportException.ExceptionType.NotOpen, "No underlying server socket."); } try { TClientTransport tSocketTransport = null; var tcpClient = await _server.AcceptTcpClientAsync(); try { tSocketTransport = new TSocketClientTransport(tcpClient) { Timeout = _clientTimeout }; if (_useBufferedSockets) { tSocketTransport = new TBufferedClientTransport(tSocketTransport); } if (_useFramedTransport) { tSocketTransport = new TFramedClientTransport(tSocketTransport); } return(tSocketTransport); } catch (Exception) { if (tSocketTransport != null) { tSocketTransport.Dispose(); } else // Otherwise, clean it up ourselves. { ((IDisposable)tcpClient).Dispose(); } throw; } } catch (Exception ex) { throw new TTransportException(ex.ToString()); } }
public TFramedClientTransport(TClientTransport transport) { if (transport == null) { throw new ArgumentNullException(nameof(transport)); } _transport = transport; InitWriteBuffer(); }
public TFramedClientTransport(TClientTransport transport) { throw new NotImplementedException("TFramedClientTransport is not fully ready for usage"); if (transport == null) { throw new ArgumentNullException(nameof(transport)); } _transport = transport; InitWriteBuffer(); }
public TFramedClientTransport(TClientTransport transport) { throw new NotImplementedException("TFramedClientTransport is not fully ready for usage"); if (transport == null) { throw new ArgumentNullException(nameof(transport)); } _transport = transport; InitWriteBuffer(); }
public TProtocol CreateProtocol(TClientTransport transport) { if (protocol == "compact") { return(new TCompactProtocol(transport)); } if (protocol == "json") { return(new TJsonProtocol(transport)); } return(new TBinaryProtocol(transport)); }
//TODO: should support only specified input transport? public TBufferedClientTransport(TClientTransport transport, int bufSize = 1024) { if (transport == null) { throw new ArgumentNullException(nameof(transport)); } if (bufSize <= 0) { throw new ArgumentOutOfRangeException(nameof(bufSize), "Buffer size must be a positive number."); } _transport = transport; _bufSize = bufSize; }
/// <summary> /// Dispose the SDK instance, don't miss this after SDK usage. /// </summary> public void Dispose() { Subscriber?.Dispose(); Subscriber = null; Storage?.Dispose(); Storage = null; RuyiNetService?.Dispose(); RuyiNetService = null; SettingSys?.Dispose(); SettingSys = null; L10NService?.Dispose(); L10NService = null; UserService?.Dispose(); UserService = null; InputMgr?.Dispose(); InputMgr = null; SpeechService?.Dispose(); SpeechService = null; Media?.Dispose(); Media = null; OverlayService?.Dispose(); OverlayService = null; lowLatencyTransport?.Close(); LowLatencyProtocol?.Dispose(); lowLatencyTransport = null; LowLatencyProtocol = null; highLatencyTransport?.Close(); HighLatencyProtocol?.Dispose(); HighLatencyProtocol = null; highLatencyTransport = null; InstanceCount--; if (InstanceCount <= 0) { factory.SDKCleanup(); } }
public TClientTransport CreateTransport() { if (url == null) { // endpoint transport TClientTransport trans = null; if (pipe != null) { trans = new TNamedPipeClientTransport(pipe); } else { if (encrypted) { var cert = GetClientCert(); if (cert == null || !cert.HasPrivateKey) { throw new InvalidOperationException("Certificate doesn't contain private key"); } trans = new TTlsSocketClientTransport(host, port, 0, cert, (sender, certificate, chain, errors) => true, null, SslProtocols.Tls | SslProtocols.Tls11 | SslProtocols.Tls12); } else { trans = new TSocketClientTransport(host, port); } } // layered transport if (buffered) { trans = new TBufferedClientTransport(trans); } if (framed) { trans = new TFramedClientTransport(trans); } return(trans); } return(new THttpClientTransport(new Uri(url), null)); }
public TCompactProtocol(TClientTransport trans) : base(trans) { TTypeToCompactType[(int)TType.Stop] = Types.Stop; TTypeToCompactType[(int)TType.Bool] = Types.BooleanTrue; TTypeToCompactType[(int)TType.Byte] = Types.Byte; TTypeToCompactType[(int)TType.I16] = Types.I16; TTypeToCompactType[(int)TType.I32] = Types.I32; TTypeToCompactType[(int)TType.I64] = Types.I64; TTypeToCompactType[(int)TType.Double] = Types.Double; TTypeToCompactType[(int)TType.String] = Types.Binary; TTypeToCompactType[(int)TType.List] = Types.List; TTypeToCompactType[(int)TType.Set] = Types.Set; TTypeToCompactType[(int)TType.Map] = Types.Map; TTypeToCompactType[(int)TType.Struct] = Types.Struct; }
protected override async Task <TClientTransport> AcceptImplementationAsync(CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(await Task.FromCanceled <TClientTransport>(cancellationToken)); } if (_server == null) { throw new TTransportException(TTransportException.ExceptionType.NotOpen, "No underlying server socket."); } try { var client = await _server.AcceptTcpClientAsync(); client.SendTimeout = client.ReceiveTimeout = _clientTimeout; //wrap the client in an SSL Socket passing in the SSL cert var tTlsSocket = new TTlsSocketClientTransport(client, _serverCertificate, true, _clientCertValidator, _localCertificateSelectionCallback, _sslProtocols); await tTlsSocket.SetupTlsAsync(); TClientTransport trans = tTlsSocket; if (_useBufferedSockets) { trans = new TBufferedClientTransport(trans); } if (_useFramedTransport) { trans = new TFramedClientTransport(trans); } return(trans); } catch (Exception ex) { throw new TTransportException(ex.ToString()); } }
static async Task RunClient() { TClientTransport clientTransport = null; try { CancellationToken token = new CancellationToken(); clientTransport = new TSocketClientTransport(IPAddress.Loopback, 9090); TProtocol protocol = new TBinaryProtocol(clientTransport); var client = new THBaseService.Client(protocol); await client.OpenTransportAsync(token); byte[] table = Encoding.UTF8.GetBytes("test"); byte[] row1 = Encoding.UTF8.GetBytes("row1"); byte[] cos = Encoding.UTF8.GetBytes("a"); TGet get = new TGet(); get.Row = row1; var regs = await client.getAllRegionLocationsAsync(table, new CancellationToken()); var rlist = await client.getMultipleAsync(table, new List <TGet> { new TGet(row1) }, new CancellationToken()); TResult reslut = await client.getAsync(table, get, new CancellationToken()); //print results Console.WriteLine("RowKey:\n{0}", Encoding.UTF8.GetString(reslut.Row)); foreach (var k in reslut.ColumnValues) { Console.WriteLine("Family:Qualifier:" + "\n" + Encoding.UTF8.GetString(k.Family) + ":" + Encoding.UTF8.GetString(k.Qualifier)); Console.WriteLine("Value:" + Encoding.UTF8.GetString(k.Value)); } } catch (Exception e) { Console.WriteLine(e); } finally { clientTransport?.Close(); } }
public TClientTransport CreateTransport() { if (url == null) { // endpoint transport TClientTransport trans = null; if (pipe != null) { trans = new TNamedPipeClientTransport(pipe); } else { if (encrypted) { var certPath = "../../keys/client.p12"; var cert = new X509Certificate2(certPath, "thrift"); trans = new TTlsSocketClientTransport(host, port, 0, cert, (o, c, chain, errors) => true, null, SslProtocols.Tls); } else { trans = new TSocketClientTransport(host, port); } } // layered transport if (buffered) { trans = new TBufferedClientTransport(trans); } if (framed) { trans = new TFramedClientTransport(trans); } return(trans); } return(new THttpClientTransport(new Uri(url), null)); }
private static async Task RunAsync(string[] args, CancellationToken cancellationToken) { var numClients = GetNumberOfClients(args); Logger.LogInformation($"Selected # of clients: {numClients}"); var transports = new TClientTransport[numClients]; for (var i = 0; i < numClients; i++) { var t = GetTransport(args); transports[i] = t; } Logger.LogInformation($"Selected client transport:{transports[0]}"); var protocols = new Tuple <Protocol, TProtocol> [numClients]; for (var i = 0; i < numClients; i++) { var p = GetProtocol(args, transports[i]); protocols[i] = p; } Logger.LogInformation($"Selected client protocol: {protocols[0].Item1}"); var tasks = new Task[numClients]; for (int i = 0; i < numClients; i++) { var task = RunClientAsync(protocols[i], cancellationToken); tasks[i] = task; } Task.WaitAll(tasks); //await Task.FromResult(1); await Task.CompletedTask; }
public ThriftClient(TClientTransport transport, IDisposable thriftclient, URL url) { this.Transport = transport; this.Thriftclient = thriftclient; this.Url = url; }
public ITAsyncProcessor GetAsyncProcessor(TClientTransport trans, TBaseServer baseServer = null) { return _tAsyncProcessor; }
public TProtocol GetProtocol(TClientTransport trans) { return(new TBinaryProtocol(trans, StrictRead, StrictWrite)); }
bool Init() { // Default to using binary protocol Func <TClientTransport, TProtocol> createProtocolFunc = (transport) => new TBinaryProtocolTS(transport); if (context.Transport == null) { if (context.endpoint == RuyiSDKContext.Endpoint.Web) { lowLatencyTransport = new THttpClientTransport(new Uri(context.RemoteAddress), null); highLatencyTransport = lowLatencyTransport; createProtocolFunc = (transport) => new TJsonProtocol(transport); } else { var host = OS.Util.GetIPAddress(context.RemoteAddress); // init and open high/low latency transport, create protocols var lowLatencyPort = context.LowLatencyPort == 0 ? ConstantsSDKDataTypesConstants.low_latency_socket_port : context.LowLatencyPort; lowLatencyTransport = new TSocketTransportTS(host, lowLatencyPort, context.Timeout <= 0 ? SDKUtility.Instance.LowLatencyTimeout : context.Timeout); var highLatencyPort = context.HighLatencyPort == 0 ? ConstantsSDKDataTypesConstants.high_latency_socket_port : context.HighLatencyPort; highLatencyTransport = new TSocketTransportTS(host, highLatencyPort, context.Timeout <= 0 ? SDKUtility.Instance.HighLatencyTimeout : context.Timeout); } } else { lowLatencyTransport = context.Transport; highLatencyTransport = context.Transport; } // If we have 1 transport we need 1 protocol, if 2 transports 2 protocol if (Object.ReferenceEquals(lowLatencyTransport, highLatencyTransport)) { LowLatencyProtocol = createProtocolFunc(lowLatencyTransport); HighLatencyProtocol = LowLatencyProtocol; lowLatencyTransport.OpenAsync().Wait(); } else { LowLatencyProtocol = createProtocolFunc(lowLatencyTransport); HighLatencyProtocol = createProtocolFunc(highLatencyTransport); Task.WaitAll( lowLatencyTransport.OpenAsync(), highLatencyTransport.OpenAsync() ); } if (!ValidateVersion()) { return(false); } var pubout = ConstantsSDKDataTypesConstants.layer0_publisher_out_uri.SetAddress(context.RemoteAddress); factory = new Layer0.ZeroMQ.MDPSDKFactory(string.Empty, pubout); // init subscriber if (context.endpoint != RuyiSDKContext.Endpoint.Web && IsFeatureEnabled(SDKFeatures.Subscriber)) { Subscriber = factory.CreateSubscriber(); } // init storage layer if (IsFeatureEnabled(SDKFeatures.Storage)) { var stoProtocol = new TMultiplexedProtocol(HighLatencyProtocol, ServiceIDs.STORAGELAYER.ServiceID()); Storage = new StorageLayerService.Client(stoProtocol); } // init braincloud service if (IsFeatureEnabled(SDKFeatures.Online)) { var bcProtocol = new TMultiplexedProtocol(HighLatencyProtocol, ServiceIDs.BCSERVICE.ServiceID()); RuyiNetService = new RuyiNetClient(bcProtocol, Storage); //BCService = new BrainCloudService.Client(bcProtocal); } // init setting system if (IsFeatureEnabled(SDKFeatures.Settings)) { var proto = new TMultiplexedProtocol(LowLatencyProtocol, ServiceIDs.SETTINGSYSTEM_EXTERNAL.ServiceID()); SettingSys = new SDK.SettingSystem.Api.SettingSystemService.Client(proto); } // init L10N if (IsFeatureEnabled(SDKFeatures.L10N)) { var proto = new TMultiplexedProtocol(LowLatencyProtocol, ServiceIDs.L10NSERVICE.ServiceID()); L10NService = new LocalizationService.Client(proto); } // user manager if (IsFeatureEnabled(SDKFeatures.Users)) { var proto = new TMultiplexedProtocol(HighLatencyProtocol, ServiceIDs.USER_SERVICE_EXTERNAL.ServiceID()); UserService = new UserServExternal.Client(proto); } // input manger if (IsFeatureEnabled(SDKFeatures.Input)) { var proto = new TMultiplexedProtocol(LowLatencyProtocol, ServiceIDs.INPUTMANAGER_EXTERNAL.ServiceID()); InputMgr = new InputManagerService.Client(proto); } if (IsFeatureEnabled(SDKFeatures.Speech)) { var proto = new TMultiplexedProtocol(HighLatencyProtocol, ServiceIDs.SPEECH.ServiceID()); SpeechService = new SpeechService.Client(proto); } if (IsFeatureEnabled(SDKFeatures.Media)) { var proto = new TMultiplexedProtocol(HighLatencyProtocol, ServiceIDs.MEDIA.ServiceID()); Media = new MediaService.Client(proto); } if (IsFeatureEnabled(SDKFeatures.Overlay)) { var proto = new TMultiplexedProtocol(LowLatencyProtocol, ServiceIDs.OVERLAYMANAGER_EXTERNAL.ServiceID()); OverlayService = new ExternalOverlayManagerService.Client(proto); } return(true); }
/// <summary> /// TJsonProtocol Constructor /// </summary> public TJsonProtocol(TClientTransport trans) : base(trans) { Context = new JSONBaseContext(this); Reader = new LookaheadReader(this); }
public ClientTest(TestParams param) { transport = param.CreateTransport(); client = new ThriftTest.Client(param.CreateProtocol(transport)); numIterations = param.numIterations; }
public TJSONProtocolWrapper(TClientTransport trans) : base(trans) { }
public TProtocol GetProtocol(TClientTransport trans) { return(new TCompactProtocol(trans)); }
public Task ProcessContextAsync(object serverContext, TClientTransport transport, CancellationToken cancellationToken) { callCount++; return(Task.CompletedTask); }
public TBinaryProtocol(TClientTransport trans, bool strictRead, bool strictWrite) : base(trans) { StrictRead = strictRead; StrictWrite = strictWrite; }
public virtual TClientTransport GetTransport(TClientTransport trans) { return trans; }
private async Task Execute(TClientTransport client, CancellationToken cancellationToken) { Logger.LogTrace("Started client request processing"); var processor = ItProcessorFactory.GetAsyncProcessor(client, this); TClientTransport inputTransport = null; TClientTransport outputTransport = null; TProtocol inputProtocol = null; TProtocol outputProtocol = null; object connectionContext = null; try { inputTransport = InputTransportFactory.GetTransport(client); outputTransport = OutputTransportFactory.GetTransport(client); inputProtocol = InputProtocolFactory.GetProtocol(inputTransport); outputProtocol = OutputProtocolFactory.GetProtocol(outputTransport); if (ServerEventHandler != null) { connectionContext = await ServerEventHandler.CreateContextAsync(inputProtocol, outputProtocol, cancellationToken); } while (!cancellationToken.IsCancellationRequested) { if (!await inputTransport.PeekAsync(cancellationToken)) { break; } if (ServerEventHandler != null) { await ServerEventHandler.ProcessContextAsync(connectionContext, inputTransport, cancellationToken); } if (!await processor.ProcessAsync(inputProtocol, outputProtocol, cancellationToken)) { break; } } } catch (TTransportException ttx) { Logger.LogTrace($"Transport exception: {ttx}"); } catch (Exception x) { Logger.LogError($"Error: {x}"); } if (ServerEventHandler != null) { await ServerEventHandler.DeleteContextAsync(connectionContext, inputProtocol, outputProtocol, cancellationToken); } inputTransport?.Close(); outputTransport?.Close(); Logger.LogTrace("Completed client request processing"); }
public virtual TClientTransport GetTransport(TClientTransport trans) { return(trans); }
/// <summary> /// /// </summary> /// <param name="trans"></param> public TBinaryProtocolTS(TClientTransport trans) : base(trans) { }
protected TProtocol(TClientTransport trans) { Trans = trans; RecursionLimit = DefaultRecursionDepth; RecursionDepth = 0; }