private void ModelOnBasicReturn(object sender, BasicReturnEventArgs args)
{
if (LogAdapter.LogEnabled)
{
LogAdapter.LogDebug("RabbitChannel",
"Message dropped. Message sent to exchange " + args.Exchange + " with routing key " + args.RoutingKey,
null);
}
var ev = this.MessageUnrouted;
if (ev == null)
{
return;
}
var envelope = new MessageEnvelope(args.BasicProperties, args.Body);
var eventArgs = new MessageUnroutedEventArgs()
{
MessageEnvelope = envelope,
Exchange = args.Exchange,
ReplyCode = args.ReplyCode,
ReplyText = args.ReplyText,
RoutingKey = args.RoutingKey
};
ev(eventArgs);
}
private void ModelOnBasicReturn(object sender, BasicReturnEventArgs e)
{
_logger.Debug(
$"Return, code: {e.ReplyCode}, message: {e.ReplyText}, message id:{e.BasicProperties.MessageId}");
_handler.MessageReturn(e);
}
private void OnBasicReturn(object?model, BasicReturnEventArgs args)
{
if (_logTraceEnabled)
{
_logger?.LogDebug(
"BasicReturn: {ReplyCode}-{ReplyText} {MessageId}",
args.ReplyCode,
args.ReplyText,
args.BasicProperties.MessageId
);
}
if (args.BasicProperties != null &&
args.BasicProperties.Headers.TryGetValue("publishTag", out var value) &&
value is byte[] bytes)
{
if (!ulong.TryParse(Encoding.UTF8.GetString(bytes), out var id))
{
return;
}
if (_publishTasks.TryRemove(id, out var published))
{
_logger?.LogWarning("returned! with {PublishTag}", id);
published.PublishReturned(args.ReplyCode, args.ReplyText);
}
}
}
void OnBasicReturn(object model, BasicReturnEventArgs args)
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("BasicReturn: {0}-{1} {2}", args.ReplyCode, args.ReplyText, args.BasicProperties.MessageId);
}
}
void OnBasicReturn(object model, BasicReturnEventArgs args)
{
LogContext.Debug?.Log("BasicReturn: {ReplyCode}-{ReplyText} {MessageId}", args.ReplyCode, args.ReplyText, args.BasicProperties.MessageId);
if (_confirmations == null)
{
return;
}
if (!args.BasicProperties.Headers.TryGetValue("publishId", out var value))
{
return;
}
var deliveryTag = value switch
{
byte[] bytes when ulong.TryParse(Encoding.UTF8.GetString(bytes), out var id) => id,
string s when ulong.TryParse(s, out var id) => id,
_ => default
};
if (deliveryTag != 0)
{
_confirmations.Returned(deliveryTag, args.ReplyCode, args.ReplyText);
}
}
private void Channel_BasicReturn(IModel model, BasicReturnEventArgs args)
{
if (_onReturn != null)
{
_onReturn(model, args);
}
}
private void Model_BasicReturn(object sender, BasicReturnEventArgs e)
{
// Called when a message was pushed to the queue, but no consumers were availble to receive it
// This only gets called if the message was pushed with the Mandatory Flag!
// We should look to use this to detect if there are no proxy clients running!
}
private void ModelOnBasicReturn(object sender, BasicReturnEventArgs args)
{
DataContractKey dataContractKey = args.BasicProperties.GetDataContractKey();
Type dataType = _sendHelper.GetDataType(dataContractKey);
if (dataType == null)
{
dataContractKey = DataContractKey.BinaryBlob;
}
object data;
if (dataContractKey.Equals(DataContractKey.BinaryBlob))
{
data = args.Body;
}
else
{
data = _configuration.Serializer.Deserialize(dataType, args.Body);
}
RawBusMessage message = _messageHelper.ConstructMessage(dataContractKey, args.BasicProperties, data);
OnMessageReturn(args.ReplyCode, args.ReplyText, message);
}
private void OnBasicReturn(object sender, BasicReturnEventArgs e)
{
if (e.BasicProperties.ReplyTo == _topic && e.BasicProperties.CorrelationId == _correlationId)
{
TearDown();
}
}
void OnBasicReturn(object model, BasicReturnEventArgs args)
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("BasicReturn: {0}-{1} {2}", args.ReplyCode, args.ReplyText, args.BasicProperties.MessageId);
}
object value;
if (args.BasicProperties.Headers.TryGetValue("publishId", out value))
{
var bytes = value as byte[];
if (bytes == null)
{
return;
}
ulong id;
if (!ulong.TryParse(Encoding.UTF8.GetString(bytes), out id))
{
return;
}
PendingPublish published;
if (_published.TryRemove(id, out published))
{
published.PublishReturned(args.ReplyCode, args.ReplyText);
}
}
}
public virtual void OnBasicReturn(BasicReturnEventArgs args)
{
BasicReturnEventHandler handler;
lock (m_eventLock)
{
handler = m_basicReturn;
}
if (handler != null)
{
foreach (BasicReturnEventHandler h in handler.GetInvocationList())
{
try
{
h(this, args);
}
catch (Exception e)
{
CallbackExceptionEventArgs exnArgs = new CallbackExceptionEventArgs(e);
exnArgs.Detail["context"] = "OnBasicReturn";
OnCallbackException(exnArgs);
}
}
}
}
private void ModelOnBasicReturn(object sender, BasicReturnEventArgs args)
{
using (Message message = _encoder.ReadMessage(new MemoryStream(args.Body), int.MaxValue))
{
_messageProcessor.Process(args.ReplyCode, args.ReplyText, message);
}
}
public void ReturnHandler(object obj, BasicReturnEventArgs args)
{
string rs = Encoding.UTF8.GetString(args.Body.ToArray());
Dispatcher.Invoke(() =>
{
tbRcv.Text += $"{rs}发送失败;退货码:{args.ReplyCode};退货说明:{args.ReplyText} \n";
});
}
private static void Channel_BasicReturn(object sender, BasicReturnEventArgs e)
{
if (e.ReplyText == "NO_ROUTE")
{
//GetChannel().QueueDeclare(e.RoutingKey, HWL_DEFAULT_EXCHANGE, e.RoutingKey, null);
////重新发送
//SendMessage(e.RoutingKey, e.Body);
}
}
private void BasicReturnEvent(object sender, BasicReturnEventArgs ea)
{
logger.LogDebug($"{nameof(BasicReturnEvent)}: Channel " +
$"{channel.ChannelNumber} returned message " +
"{MessageId} with reply {MessageReturnedReason}",
ea.BasicProperties.MessageId, $"{ea.ReplyCode}-{ea.ReplyText}");
missingRoute = (ea.ReplyCode == MissingRoute);
}
/// <summary>
/// This method is subscribed to the the event BasicReturn from the channel instance.
/// </summary>
/// <param name="sender">Represents the sender of the event.</param>
/// <param name="e">Represents the event arguments.</param>
private void MqBasicReturn(object sender, BasicReturnEventArgs e)
{
Console.WriteLine(sender);
Console.WriteLine(e);
string message = Encoding.UTF8.GetString(e.Body);
string routingKey = e.RoutingKey;
Console.WriteLine("NOT DELIVERED: Agent: [ {0} ] Message: [ {1} ] ", routingKey, message);
}
// return类似于nack，不同在于return通常代表着unroutable，
// 所以log一下但并不会重试，消息的状态也直接置为终结态Error_Unroutable：5
private void Channel_BasicReturn(object sender, BasicReturnEventArgs e)
{
_repository.Update(new UpdateParam
{
MsgId = e.BasicProperties.MessageId,
OldState = MessageState.Created,
NewState = MessageState.Error_Unroutable,
Remark = $"Broker Return，ReplyCode：{e.ReplyCode}，ReplyText：{e.ReplyText}",
ModifyTime = DateTime.Now
});
}
private void OnReturn(object sender, BasicReturnEventArgs args)
{
var returnedMessageEvent = new ReturnedMessageEvent(
(IModel)sender,
args.Body.ToArray(),
new MessageProperties(args.BasicProperties),
new MessageReturnedInfo(args.Exchange, args.RoutingKey, args.ReplyText)
);
eventBus.Publish(returnedMessageEvent);
}
void Channel_BasicReturn(object sender, BasicReturnEventArgs e)
{
var message = $"Message could not be routed to {e.Exchange + e.RoutingKey}: {e.ReplyCode} {e.ReplyText}";
if (e.BasicProperties.TryGetConfirmationId(out var deliveryTag))
{
SetException(deliveryTag, message);
}
else
{
Logger.Warn(message);
}
}
private void Fatal(BasicReturnEventArgs a)
{
lock (_oSendLock)
{
if (OnFatal != null)
{
OnFatal.Invoke(this, a);
}
else
{
throw new ApplicationException("No subscribers for fatal error event");
}
}
}
/// <summary>
/// 这个事件就是用来监听我们一些不可达的消息的内容的：比如某些情况下，如果我们在发送消息时，当前的exchange不存在或者指定的routingkey路由不到，这个时候如果要监听这种不可达的消息，就要使用 return
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void BasicReturnEventHandler(object?o, BasicReturnEventArgs basic)
{
var rc = basic.ReplyCode; //消息失败的code
var rt = basic.ReplyText; //描述返回原因的文本。
var msg = Encoding.UTF8.GetString(basic.Body.ToArray()); //失败消息的内容
//在这里我们可能要对这条不可达消息做处理，比如是否重发这条不可达的消息呀，或者这条消息发送到其他的路由中呀，等等
//System.IO.File.AppendAllText("d:/return.txt", "调用了Return;ReplyCode:" + rc + ";ReplyText:" + rt + ";Body:" + msg);
MQWebApiMsg Data = Newtonsoft.Json.JsonConvert.DeserializeObject <MQWebApiMsg>(msg);
PushErrorEvent?.Invoke(Data);
Log.WriteLine($"异常事件 BasicReturn: ReplyCode:{rc};ReplyText:{rt};Body:{msg},all:{Newtonsoft.Json.JsonConvert.SerializeObject(basic)}");
//Console.WriteLine($"-------- BasicReturn: ReplyCode:{rc};ReplyText:{rt};Body:{msg}");
}
public void HandleBasicReturn(ushort replyCode,
string replyText,
string exchange,
string routingKey,
IBasicProperties basicProperties,
byte[] body)
{
BasicReturnEventArgs e = new BasicReturnEventArgs();
e.ReplyCode = replyCode;
e.ReplyText = replyText;
e.Exchange = exchange;
e.RoutingKey = routingKey;
e.BasicProperties = basicProperties;
e.Body = body;
OnBasicReturn(e);
}
private void ModelOnBasicReturn(object sender, BasicReturnEventArgs args)
{
DataContractKey dataContractKey = args.BasicProperties.GetDataContractKey();
Type dataType = _nameMappings.Where(pair => pair.Value.Equals(dataContractKey)).Select(pair => pair.Key).FirstOrDefault();
if (dataType == null)
{
dataContractKey = DataContractKey.BinaryBlob;
}
object data = _configuration.Serializer.Deserialize(dataContractKey, dataType, args.Body);
RawBusMessage message = _messageHelper.ConstructMessage(dataContractKey, args.BasicProperties, data);
_configuration.ErrorHandler.DeliveryFailed(args.ReplyCode, args.ReplyText, message);
}
public void Handler(object sender, BasicReturnEventArgs e, IPublishedMessageStore publishedMessageStore)
{
using (var tx = publishedMessageStore.BeginTransaction())
{
string body = Encoding.UTF8.GetString(e.Body);
RmqPublishMessage returnedMessage = JsonConvert.DeserializeObject <RmqPublishMessage>(body);
RmqPublishMessage foundMessage = publishedMessageStore.GetByMessageId(returnedMessage.MessageId);
foundMessage.Status = MessageStatusConstants.Unroutable;
foundMessage.StatusReason = e.ReplyText;
publishedMessageStore.Update(foundMessage);
publishedMessageStore.Commit(tx);
}
}
private void BasicReturn(object sender, BasicReturnEventArgs e)
{
byte[] body = e.Body;
string message = Encoding.UTF8.GetString(body);
var parameters = new Dictionary <string, object>
{
{ "exchange", e.Exchange }
, { "routingKey", e.RoutingKey }
};
_logger.LogError("BasicReturn message has been received from RabbitMQ. Session {@Sender} BasicReturnEventArgs {ReplyText} {ReplyCode} {EventName} {@Parameters} {Message}"
, sender.ToString()
, e.ReplyText
, e.ReplyCode
, e.BasicProperties.Type
, parameters
, message);
}
private void ChannelOnBasicReturn(object sender, BasicReturnEventArgs ea)
{
var body = Encoding.UTF8.GetString(ea.Body);
_Logger.LogError("Sending message to the broker failed. Body: {0}", body);
CleanOutstandingConfirms(body);
if (IsReSent(ea))
{
Send(SystemEventType.DeadEnd, body);
_Logger.LogError("Resend to dead letter. Body: {0}", body);
}
else
{
SendToQueue(ea.RoutingKey, body, true);
_Logger.LogError("Resend to current queue. Body: {0}, queue {1}", body, ea.RoutingKey);
}
}
public void MessageReturn(BasicReturnEventArgs info)
{
if (info.BasicProperties.Headers.TryGetValue(CorrelationHeader, out var correlationValue))
{
try
{
var correlationId = correlationValue is string
?(string)correlationValue
: Encoding.UTF8.GetString(correlationValue as byte[]);
if (correlationId != null)
{
_ackQueue.Return(correlationId, info.ReplyText);
}
}
catch
{
// no-op
}
}
}
internal void ConfigureEvents(IModel model)
{
if (BasicReturnCallback != null)
{
model.BasicReturn += (sender, args) =>
{
var transportMessage = RabbitMqTransport.CreateTransportMessage(args.BasicProperties, args.Body);
var eventArgs = new BasicReturnEventArgs(
transportMessage,
args.Exchange,
args.ReplyCode,
args.ReplyText,
args.RoutingKey
);
BasicReturnCallback(sender, eventArgs);
};
}
}
void Channel_BasicReturn(object sender, BasicReturnEventArgs e)
{
Task.Run(() =>
{
var message = $"Message could not be routed to {e.Exchange + e.RoutingKey}: {e.ReplyCode} {e.ReplyText}";
ulong deliveryTag;
if (e.BasicProperties.TryGetConfirmationId(out deliveryTag))
{
TaskCompletionSource <bool> tcs;
messages.TryRemove(deliveryTag, out tcs);
tcs?.SetException(new Exception(message));
}
else
{
Logger.Warn(message);
}
});
}
void OnBasicReturn(object model, BasicReturnEventArgs args)
{
LogContext.Debug?.Log("BasicReturn: {ReplyCode}-{ReplyText} {MessageId}", args.ReplyCode, args.ReplyText, args.BasicProperties.MessageId);
if (args.BasicProperties.Headers.TryGetValue("publishId", out var value))
{
var bytes = value as byte[];
if (bytes == null)
{
return;
}
if (!ulong.TryParse(Encoding.UTF8.GetString(bytes), out var id))
{
return;
}
if (_published.TryRemove(id, out var published))
{
published.PublishReturned(args.ReplyCode, args.ReplyText);
}
}
}
