public void CleanUp()
{
var connectionClosedException =
new ConnectionClosedException("Connection was closed.");
foreach (var channel in _channels.Values)
{
channel.Fail(connectionClosedException);
}
_channels.Clear();
}
public void CleanUp()
{
var connectionClosedException = new ConnectionClosedException(string.Format("Connection '{0}' was closed.", _connectionName));
foreach (var subscription in _activeSubscriptions.Values
.Concat(_waitingSubscriptions)
.Concat(_retryPendingSubscriptions))
{
subscription.Operation.DropSubscription(SubscriptionDropReason.ConnectionClosed, connectionClosedException);
}
_activeSubscriptions.Clear();
_waitingSubscriptions.Clear();
_retryPendingSubscriptions.Clear();
}
public void CleanUp()
{
var connectionClosedException = new ConnectionClosedException(string.Format("Connection '{0}' was closed.", _connectionName));
foreach (var operation in _activeOperations.Values
.Concat(_waitingOperations)
.Concat(_retryPendingOperations))
{
operation.Operation.Fail(connectionClosedException);
}
_activeOperations.Clear();
_waitingOperations.Clear();
_retryPendingOperations.Clear();
_totalOperationCount = 0;
}
public void CleanUp()
{
var connectionClosedException =
new ConnectionClosedException("Connection was closed.");
foreach (var operation in _activeOperations.Values
.Concat(_waitingOperations)
.Concat(_retryPendingOperations))
{
operation.Operation.Fail(connectionClosedException);
}
_activeOperations.Clear();
OperationItem dummy;
while (_waitingOperations.TryDequeue(out dummy))
{
;
}
_retryPendingOperations.Clear();
_totalOperationCount = 0;
}
/// <seealso cref= Runnable#run() </seealso>
public void run()
{
InvokeCallback callback = future.InvokeCallback;
// a lot of try-catches to protect thread pool
ResponseCommand response = null;
try
{
response = (ResponseCommand)future.waitResponse(0);
}
catch (ThreadInterruptedException e)
{
string msg = "Exception caught when getting response from InvokeFuture. The address is " + remoteAddress;
logger.LogError(msg, e);
}
if (response == null || response.ResponseStatus != ResponseStatus.SUCCESS)
{
try
{
System.Exception e;
if (response == null)
{
e = new InvokeException("Exception caught in invocation. The address is " + remoteAddress + " responseStatus:" + ResponseStatus.UNKNOWN, future.Cause);
}
else
{
response.InvokeContext = future.InvokeContext;
switch (response.ResponseStatus)
{
case ResponseStatus.TIMEOUT:
e = new InvokeTimeoutException("Invoke timeout when invoke with callback.The address is " + remoteAddress);
break;
case ResponseStatus.CONNECTION_CLOSED:
e = new ConnectionClosedException("Connection closed when invoke with callback.The address is " + remoteAddress);
break;
case ResponseStatus.SERVER_THREADPOOL_BUSY:
e = new InvokeServerBusyException("Server thread pool busy when invoke with callback.The address is " + remoteAddress);
break;
case ResponseStatus.SERVER_EXCEPTION:
string msg = "Server exception when invoke with callback.Please check the server log! The address is " + remoteAddress;
RpcResponseCommand resp = (RpcResponseCommand)response;
resp.deserialize();
object ex = resp.ResponseObject;
if (ex != null && ex is System.Exception)
{
e = new InvokeServerException(msg, (System.Exception)ex);
}
else
{
e = new InvokeServerException(msg);
}
break;
default:
e = new InvokeException("Exception caught in invocation. The address is " + remoteAddress + " responseStatus:" + response.ResponseStatus, future.Cause);
break;
}
}
callback.onException(e);
}
catch (System.Exception e)
{
logger.LogError("Exception occurred in user defined InvokeCallback#onException() logic, The address is {}", remoteAddress, e);
}
}
else
{
try
{
response.InvokeContext = future.InvokeContext;
RpcResponseCommand rpcResponse = (RpcResponseCommand)response;
response.deserialize();
try
{
callback.onResponse(rpcResponse.ResponseObject);
}
catch (System.Exception e)
{
logger.LogError("Exception occurred in user defined InvokeCallback#onResponse() logic.", e);
}
}
catch (CodecException e)
{
logger.LogError("CodecException caught on when deserialize response in RpcInvokeCallbackListener. The address is {}.", remoteAddress, e);
}
catch (System.Exception e)
{
logger.LogError("Exception caught in RpcInvokeCallbackListener. The address is {}", remoteAddress, e);
}
finally
{
}
} // enf of else
} // end of run
private async Task RunReaderAsync()
{
try
{
if (IsServer)
{
EnsureBuffer(ClientPreface.Length);
await ClientPreface.ReadAsync(inputStream, config.ClientPrefaceTimeout);
}
var continueRead = true;
if (serverUpgradeRequest != null)
{
var upgrade = serverUpgradeRequest;
serverUpgradeRequest = null;
var headers = new CompleteHeadersFrameData
{
StreamId = 1u,
Priority = null,
Headers = upgrade.Headers,
EndOfStream = upgrade.Payload == null,
};
var err = await HandleHeaders(headers);
if (err != null)
{
if (err.Value.StreamId == 0)
{
continueRead = false;
}
await HandleFrameProcessingError(err.Value);
}
else if (upgrade.Payload != null)
{
var buf = config.BufferPool.Rent(upgrade.Payload.Length);
Array.Copy(
upgrade.Payload, 0, buf, 0, upgrade.Payload.Length);
StreamImpl stream = null;
lock (shared.Mutex)
{
shared.streamMap.TryGetValue(1u, out stream);
}
bool tookBufferOwnership;
err = stream.PushBuffer(
new ArraySegment <byte>(buf, 0, upgrade.Payload.Length),
true,
out tookBufferOwnership);
if (!tookBufferOwnership)
{
config.BufferPool.Return(buf);
}
if (err != null)
{
if (err.Value.StreamId == 0)
{
continueRead = false;
}
await HandleFrameProcessingError(err.Value);
}
}
}
while (continueRead)
{
EnsureBuffer(PersistentBufferSize);
var err = await ReadOneFrame();
ReleaseBuffer(PersistentBufferSize);
if (err != null)
{
if (err.Value.StreamId == 0)
{
continueRead = false;
}
await HandleFrameProcessingError(err.Value);
}
}
}
catch (Exception e)
{
}
await writer.CloseNow();
await writer.Done;
Dictionary <uint, StreamImpl> activeStreams = null;
lock (shared.Mutex)
{
activeStreams = shared.streamMap;
shared.streamMap = null;
shared.Closed = true;
}
foreach (var kvp in activeStreams)
{
await kvp.Value.Reset(ErrorCode.ConnectError, fromRemote : true);
}
PingState pingState = null;
lock (shared.Mutex)
{
if (shared.PingState != null)
{
pingState = shared.PingState;
shared.PingState = null;
}
}
if (pingState != null)
{
var ex = new ConnectionClosedException();
foreach (var kvp in pingState.PingMap)
{
kvp.Value.SetException(ex);
}
}
if (!remoteGoAwayTcs.Task.IsCompleted)
{
remoteGoAwayTcs.TrySetException(new EndOfStreamException());
}
if (receiveBuffer != null)
{
config.BufferPool.Return(receiveBuffer);
receiveBuffer = null;
}
headerReader.Dispose();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private static void preProcess(ResponseCommand responseCommand, String addr) throws exception.RemotingException
private static void preProcess(ResponseCommand responseCommand, string addr)
{
RemotingException e = null;
string msg = null;
if (responseCommand == null)
{
msg = string.Format("Rpc invocation timeout[responseCommand null]! the address is {0}", addr);
e = new InvokeTimeoutException(msg);
}
else
{
switch (responseCommand.ResponseStatus)
{
case ResponseStatus.TIMEOUT:
msg = string.Format("Rpc invocation timeout[responseCommand TIMEOUT]! the address is {0}", addr);
e = new InvokeTimeoutException(msg);
break;
case ResponseStatus.CLIENT_SEND_ERROR:
msg = string.Format("Rpc invocation send failed! the address is {0}", addr);
e = new InvokeSendFailedException(msg, responseCommand.Cause);
break;
case ResponseStatus.CONNECTION_CLOSED:
msg = string.Format("Connection closed! the address is {0}", addr);
e = new ConnectionClosedException(msg);
break;
case ResponseStatus.SERVER_THREADPOOL_BUSY:
msg = string.Format("Server thread pool busy! the address is {0}, id={1}", addr, responseCommand.Id);
e = new InvokeServerBusyException(msg);
break;
case ResponseStatus.CODEC_EXCEPTION:
msg = string.Format("Codec exception! the address is {0}, id={1}", addr, responseCommand.Id);
e = new CodecException(msg);
break;
case ResponseStatus.SERVER_SERIAL_EXCEPTION:
msg = string.Format("Server serialize response exception! the address is {0}, id={1}, serverSide=true", addr, responseCommand.Id);
e = new SerializationException(detailErrMsg(msg, responseCommand), toThrowable(responseCommand), true);
break;
case ResponseStatus.SERVER_DESERIAL_EXCEPTION:
msg = string.Format("Server deserialize request exception! the address is {0}, id={1}, serverSide=true", addr, responseCommand.Id);
e = new DeserializationException(detailErrMsg(msg, responseCommand), toThrowable(responseCommand), true);
break;
case ResponseStatus.SERVER_EXCEPTION:
msg = string.Format("Server exception! Please check the server log, the address is {0}, id={1}", addr, responseCommand.Id);
e = new InvokeServerException(detailErrMsg(msg, responseCommand), toThrowable(responseCommand));
break;
default:
break;
}
}
if (!string.IsNullOrWhiteSpace(msg))
{
logger.LogWarning(msg);
}
if (null != e)
{
throw e;
}
}
private void ChannelRegistration <T>(IBasicProperties basicProperties, string queue, string errorQueue, string exchange, string routingKey, ConsumerResolver <T> resolver)
{
var rabbitConsumer = new EventingBasicConsumer(channel);
rabbitConsumer.Received += (model, ea) =>
{
var serializer = RabbitMQWrapperConnection.DefaultAdapter;
try
{
var message = serializer.DeserializeBytes <RabbitMQWrapperMessage <T> >(ea.Body);
AbstractConsumer <T> consumer = null;
try
{
consumer = resolver(message.EventID, message.Event, message.ContractVersion);
if (message.Event == "")
{
consumer.Consume(message.EventID, message.Content, message.ContractVersion);
}
consumer.Consume(message.Event, message.Content, message.ContractVersion);
}
catch (Exception e)
{
Logger.Error("Consumer: " + consumer + " has unexpected error", e);
channel.BasicNack(deliveryTag: ea.DeliveryTag, multiple: false, requeue: true);
return;
}
try
{
channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
}
catch (Exception e)
{
Logger.Error("Connection lost", e);
throw e;
}
}
catch (JsonException e)
{
var customError = new UnexpectedException(e);
Logger.Error("Could not deserialize the object: " + ea.Body, customError);
try
{
Logger.Warn("Creating error queue...");
this.EnsureRoute(errorQueue, exchange, routingKey);
this.channel.BasicPublish(exchange: exchange, routingKey: routingKey, basicProperties: basicProperties, body: ea.Body);
channel.BasicNack(deliveryTag: ea.DeliveryTag, multiple: false, requeue: false);
}
catch (Exception ex)
{
var custom = new UnexpectedException(ex);
Logger.Fatal("Unexpected error occured while publishing items to error queue", custom);
throw custom;
}
}
catch (Exception e)
{
var custom = new UnexpectedException(e);
Logger.Fatal("Unexpected error occured while consumer received a message", custom);
throw custom;
}
};
try
{
channel.BasicConsume(queue: queue, noAck: false, consumer: rabbitConsumer, consumerTag: appKey);
}
catch (IOException e)
{
if (channel.IsOpen == false)
{
var custom = new ConnectionClosedException(e);
Logger.Info("Trying to reconnect again... Queue:" + queue, custom);
Thread.Sleep(200);
channel.BasicConsume(queue: queue, noAck: false, consumer: rabbitConsumer, consumerTag: appKey);
}
else
{
var custom = new AccessDeniedException(e);
Logger.Fatal("Access denied. Queue: " + queue, custom);
throw custom;
}
}
}
