/// <summary> /// /// </summary> /// <param name="ctx"></param> /// <param name="message"></param> protected override void ChannelRead0(IChannelHandlerContext ctx, ThriftMessage message) { message.ProcessStartTimeTicks = DateTime.UtcNow.Ticks; CheckResponseOrderingRequirements(ctx, message); TNiftyTransport messageTransport = new TNiftyTransport(ctx.Channel, message, true); TTransportPair transportPair = TTransportPair.FromSingleTransport(messageTransport); TProtocolPair protocolPair = this._duplexProtocolFactory.GetProtocolPair(transportPair); TProtocol inProtocol = protocolPair.InputProtocol; TProtocol outProtocol = protocolPair.OutputProtocol; long requestSequenceId = BlockReadingForOrderReponse(ctx); IByteBuffer buffer = message.Buffer; buffer.Retain(); _factory.StartNew(() => ProcessRequestAsync(requestSequenceId, ctx, message, messageTransport, inProtocol, outProtocol) .ContinueWith(t => { inProtocol.Dispose(); outProtocol.Dispose(); buffer.Release(); messageTransport?.Dispose(); })); }
//初始化 public bool Init() { lock (this) { try { transport = new TSocket(m_host, m_port, m_timeout); protocol = new TBinaryProtocol(transport); TMultiplexedProtocol mp = new TMultiplexedProtocol(protocol, "SercurityService"); SercurityClient = new SercurityService.Client(mp); TMultiplexedProtocol mp2 = new TMultiplexedProtocol(protocol, "SaleService"); SaleClient = new SaleService.Client(mp2); TMultiplexedProtocol mp3 = new TMultiplexedProtocol(protocol, "DataSyncService"); DataSyncClient = new DataSyncService.Client(mp3); if (transport != null && !transport.IsOpen) { transport.Open(); } return(true); } catch (Exception ex) { if (transport != null) { transport.Dispose(); } if (protocol != null) { protocol.Dispose(); } if (DataSyncClient != null) { DataSyncClient.Dispose(); } if (SaleClient != null) { SaleClient.Dispose(); } if (SercurityClient != null) { SercurityClient.Dispose(); } if (SystemClient != null) { SystemClient.Dispose(); } transport = null; protocol = null; SercurityClient = null; SystemClient = null; SaleClient = null; DataSyncClient = null; _log.Error(ex.Message.ToString()); return(false); } } }
public new void Dispose() { (_messageSender as IDisposable)?.Dispose(); foreach (var taskCompletionSource in _resultDictionary.Values) { taskCompletionSource.SetCanceled(); } base.Dispose(); _protocol.Dispose(); }
protected virtual void Dispose(bool disposing) { if (!_isDisposed) { if (disposing) { _outputProtocol?.Dispose(); } } _isDisposed = true; }
public void Dispose() { if (_transport != null) { _transport.Dispose(); } if (_protocol != null) { _protocol.Dispose(); } }
//释放链接 public void Dispose() { lock (this) { try { if (transport != null && transport.IsOpen) { transport.Close(); } if (transport != null) { transport.Dispose(); } if (protocol != null) { protocol.Dispose(); } if (DataSyncClient != null) { DataSyncClient.Dispose(); } if (SaleClient != null) { SaleClient.Dispose(); } if (SercurityClient != null) { SercurityClient.Dispose(); } if (SystemClient != null) { SystemClient.Dispose(); } transport = null; protocol = null; SercurityClient = null; SystemClient = null; SaleClient = null; DataSyncClient = null; } catch (Exception ex) { throw new Exception(ex.Message.ToString()); } } }
private async Task Execute(TTransport client, CancellationToken cancellationToken) { Logger.LogTrace("Started client request processing"); var processor = ProcessorFactory.GetAsyncProcessor(client, this); TTransport inputTransport = null; TTransport outputTransport = null; TProtocol inputProtocol = null; TProtocol outputProtocol = null; object connectionContext = null; try { 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); } } finally { //Close transports inputTransport?.Close(); outputTransport?.Close(); // disposable stuff should be disposed inputProtocol?.Dispose(); outputProtocol?.Dispose(); inputTransport?.Dispose(); outputTransport?.Dispose(); } Logger.LogTrace("Completed client request processing"); }
public void Dispose() { _protocol.Dispose(); }
private void ClientWorker(object context) { using (TTransport client = (TTransport)context) { TProcessor processor = processorFactory.GetProcessor(client); TTransport inputTransport = null; TTransport outputTransport = null; TProtocol inputProtocol = null; TProtocol outputProtocol = null; object connectionContext = null; try { try { inputTransport = inputTransportFactory.GetTransport(client); outputTransport = outputTransportFactory.GetTransport(client); inputProtocol = inputProtocolFactory.GetProtocol(inputTransport); outputProtocol = outputProtocolFactory.GetProtocol(outputTransport); //Recover event handler (if any) and fire createContext server event when a client connects if (serverEventHandler != null) { connectionContext = serverEventHandler.createContext(inputProtocol, outputProtocol); } //Process client requests until client disconnects while (!stop) { if (!inputTransport.Peek()) { break; } //Fire processContext server event //N.B. This is the pattern implemented in C++ and the event fires provisionally. //That is to say it may be many minutes between the event firing and the client request //actually arriving or the client may hang up without ever makeing a request. if (serverEventHandler != null) { serverEventHandler.processContext(connectionContext, inputTransport); } //Process client request (blocks until transport is readable) if (!processor.Process(inputProtocol, outputProtocol)) { break; } } } catch (TTransportException) { //Usually a client disconnect, expected } catch (Exception x) { //Unexpected logDelegate("Error: " + x); } //Fire deleteContext server event after client disconnects if (serverEventHandler != null) { serverEventHandler.deleteContext(connectionContext, inputProtocol, outputProtocol); } lock (clientLock) { clientThreads.Remove(Thread.CurrentThread); Monitor.Pulse(clientLock); } } finally { //Close transports if (inputTransport != null) { inputTransport.Close(); } if (outputTransport != null) { outputTransport.Close(); } // disposable stuff should be disposed if (inputProtocol != null) { inputProtocol.Dispose(); } if (outputProtocol != null) { outputProtocol.Dispose(); } } } }
/// <summary> /// Loops on processing a client forever /// client will be a TTransport instance /// </summary> /// <param name="client"></param> private async Task ExecuteAsync(TTransport client) { var cancellationToken = ServerCancellationToken; var processor = ProcessorFactory.GetAsyncProcessor(client, this); TTransport inputTransport = null; TTransport outputTransport = null; TProtocol inputProtocol = null; TProtocol outputProtocol = null; object connectionContext = null; try { try { inputTransport = InputTransportFactory.GetTransport(client); outputTransport = OutputTransportFactory.GetTransport(client); inputProtocol = InputProtocolFactory.GetProtocol(inputTransport); outputProtocol = OutputProtocolFactory.GetProtocol(outputTransport); //Recover event handler (if any) and fire createContext server event when a client connects if (ServerEventHandler != null) { connectionContext = await ServerEventHandler.CreateContextAsync(inputProtocol, outputProtocol, cancellationToken); } //Process client requests until client disconnects while (!(stop || cancellationToken.IsCancellationRequested)) { if (!await inputTransport.PeekAsync(cancellationToken)) { break; } //Fire processContext server event //N.B. This is the pattern implemented in C++ and the event fires provisionally. //That is to say it may be many minutes between the event firing and the client request //actually arriving or the client may hang up without ever makeing a request. if (ServerEventHandler != null) { await ServerEventHandler.ProcessContextAsync(connectionContext, inputTransport, cancellationToken); } //Process client request (blocks until transport is readable) if (!await processor.ProcessAsync(inputProtocol, outputProtocol, cancellationToken)) { break; } } } catch (TTransportException) { //Usually a client disconnect, expected } catch (Exception x) { //Unexpected LogError("Error: " + x); } //Fire deleteContext server event after client disconnects if (ServerEventHandler != null) { await ServerEventHandler.DeleteContextAsync(connectionContext, inputProtocol, outputProtocol, cancellationToken); } } finally { //Close transports inputTransport?.Close(); outputTransport?.Close(); // disposable stuff should be disposed inputProtocol?.Dispose(); outputProtocol?.Dispose(); inputTransport?.Dispose(); outputTransport?.Dispose(); } }
public void GlobalCleanup() { _Protocol.Dispose(); }