public override void Close()
{
this.ClientChannel.CloseAsync().GetAwaiter().GetResult();
this._requestBufferTransport?.Dispose();
this._responseBufferTransport?.Dispose();
this._requestBufferTransport = null;
this._responseBufferTransport = null;
}
public Object Invoke(
IRequestChannel channel,
TChannelBufferInputTransport inputTransport,
TChannelBufferOutputTransport outputTransport,
TProtocol inputProtocol,
TProtocol outputProtocol,
int sequenceId,
ClientContextChain contextChain,
params object[] args)
{
return(InnerInvoke(channel, inputTransport, outputTransport, inputProtocol, outputProtocol, sequenceId, contextChain, args));
}
public TNiftyClientChannelTransport(Type clientType, INiftyClientChannel channel)
{
Guard.ArgumentNotNull(clientType, nameof(clientType));
this._clientClass = clientType;
this._channel = channel;
this._methodNameToOneWay = new Dictionary <string, bool>();
this._requestBufferTransport = new TChannelBufferOutputTransport();
//think: Unpooled 0 是否不需要释放资源？
this._responseBufferTransport = new TChannelBufferInputTransport(Unpooled.Buffer(0, 0));
this._queuedResponses = new ConcurrentQueue <ResponseListener>();
}
public Fake(string clientDescription, ThriftClientMetadata clientMetadata, IRequestChannel channel,
IEnumerable <ThriftClientEventHandler> immutableList)
{
this.Channel = channel;
this._clientMetadata = clientMetadata;
this._clientDescription = clientDescription;
this.methodHandlers = clientMetadata.MethodHandlers;
this.eventHandlers = immutableList;
this._inputTransport = new TChannelBufferInputTransport();
this._outputTransport = new TChannelBufferOutputTransport();
var transportPair = TTransportPair.FromSeparateTransports(this._inputTransport, this._outputTransport);
var protocolPair = channel.ProtocolFactory.GetProtocolPair(transportPair);
this.InputProtocol = protocolPair.InputProtocol;
this.OutputProtocol = protocolPair.OutputProtocol;
}
private void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
this._inputTransport?.Dispose();
this._outputTransport?.Dispose();
this.InputProtocol?.Dispose();
this._outputTransport?.Dispose();
this._inputTransport = null;
this._outputTransport = null;
this.InputProtocol = null;
this.OutputProtocol = null;
}
_disposed = true;
}
}
private object InnerInvoke(IRequestChannel channel, TChannelBufferInputTransport inputTransport,
TChannelBufferOutputTransport outputTransport, TProtocol inputProtocol, TProtocol outputProtocol, int sequenceId,
ClientContextChain contextChain, object[] args)
{
if (_invokeAsynchronously)
{
// This method declares a Future return value: run it asynchronously
return(AsynchronousInvoke(channel, inputTransport, outputTransport, inputProtocol, outputProtocol, sequenceId,
contextChain, args));
}
else
{
try
{
// This method declares an immediate return value: run it synchronously
return(SynchronousInvoke(channel, inputTransport, outputTransport, inputProtocol, outputProtocol,
sequenceId, contextChain, args));
}
finally
{
contextChain.Done();
}
}
}
public Task AsynchronousInvoke(
IRequestChannel channel,
TChannelBufferInputTransport inputTransport,
TChannelBufferOutputTransport outputTransport,
TProtocol inputProtocol,
TProtocol outputProtocol,
int sequenceId,
ClientContextChain contextChain,
Object[] args)
{
//Mark: 微软没有提供 TaskCompletionSource 的非泛型类型，只能使用动态类型处理。
TaskCompletionSourceEx future;
if (_successCodec.Type != ThriftType.Void)
{
future = new TaskCompletionSourceEx(_successCodec.Type.CSharpType);
}
else
{
future = new TaskCompletionSourceEx(typeof(Object));
}
var requestContext = RequestContexts.GetCurrentContext();
contextChain.PreWrite(args);
outputTransport.ResetOutputBuffer();
WriteArguments(outputProtocol, sequenceId, args);
IByteBuffer requestBuffer = outputTransport.OutputBuffer.Copy();
contextChain.PostWrite(args);
requestBuffer.Retain();
channel.SendAsynchronousRequest(requestBuffer, false,
new RequestListener(
onRequestSent: reqs =>
{
reqs.Release();
if (this._oneway)
{
try
{
ForceDoneChain(contextChain);
future.TrySetResult(null);
}
catch (Exception e)
{
ForceDoneChain(contextChain);
future.TrySetException(e);
}
}
},
onResponseReceive: message =>
{
IRequestContext oldRequestContext = RequestContexts.GetCurrentContext();
RequestContexts.SetCurrentContext(requestContext);
try
{
contextChain.PreRead();
inputTransport.SetInputBuffer(message);
WaitForResponse(inputProtocol, sequenceId);
Object results = ReadResponse(inputProtocol);
contextChain.PostRead(results);
ForceDoneChain(contextChain);
future.TrySetResult(results);
}
catch (Exception e)
{
var wrapException = ThriftClientManager.WrapTException(e);
contextChain.PostReadException(e);
ForceDoneChain(contextChain);
future.TrySetException(wrapException);
}
finally
{
RequestContexts.SetCurrentContext(oldRequestContext);
}
},
onChannelError: e =>
{
if (requestBuffer.ReferenceCount > 0)
{
requestBuffer.Release();
}
IRequestContext oldRequestContext = RequestContexts.GetCurrentContext();
RequestContexts.SetCurrentContext(requestContext);
try
{
contextChain.PreReadException(e);
ForceDoneChain(contextChain);
var wrappedException = ThriftClientManager.WrapTException(e);
future.TrySetException(wrappedException);
}
finally
{
RequestContexts.SetCurrentContext(oldRequestContext);
}
}
));
return(future.Task);
}
private Object SynchronousInvoke(
IRequestChannel channel,
TChannelBufferInputTransport inputTransport,
TChannelBufferOutputTransport outputTransport,
TProtocol inputProtocol,
TProtocol outputProtocol,
int sequenceId,
ClientContextChain contextChain,
Object[] args)
{
Object results = null;
// write request
contextChain.PreWrite(args);
outputTransport.ResetOutputBuffer();
WriteArguments(outputProtocol, sequenceId, args);
// Don't need to copy the output buffer for sync case
IByteBuffer requestBuffer = outputTransport.OutputBuffer;
contextChain.PostWrite(args);
if (!this._oneway)
{
IByteBuffer responseBuffer;
try
{
responseBuffer = SyncClientHelpers.SendSynchronousTwoWayMessage(channel, requestBuffer);
}
catch (Exception e)
{
contextChain.PreReadException(e);
throw;
}
finally
{
requestBuffer.Release();
}
// read results
contextChain.PreRead();
try
{
inputTransport.SetInputBuffer(responseBuffer);
WaitForResponse(inputProtocol, sequenceId);
results = ReadResponse(inputProtocol);
contextChain.PostRead(results);
}
catch (Exception e)
{
contextChain.PostReadException(e);
throw;
}
}
else
{
try
{
SyncClientHelpers.SendSynchronousOneWayMessage(channel, requestBuffer);
}
catch (Exception)
{
throw;
}
}
return(results);
}
