public void OnCreate(Connection.IConnection connection) { _logger?.LogDebug("OnCreate for connection: {connection}", connection?.ToString()); if (Interlocked.CompareExchange(ref _initializing, 1, 0) != 0) { return; } try { /* * ...but it is possible for this to happen twice in the same ConnectionFactory (if more than * one concurrent Connection is allowed). It's idempotent, so no big deal (a bit of network * chatter). In fact it might even be a good thing: exclusive queues only make sense if they are * declared for every connection. If anyone has a problem with it: use auto-startup="false". */ if (RetryTemplate != null && !RetryDisabled) { RetryTemplate.Execute( c => { Initialize(); }); } else { Initialize(); } } finally { Interlocked.CompareExchange(ref _initializing, 0, 1); } }
public StatefulRetryOperationsInterceptor() : base() { var retryTemplate = new RetryTemplate(); retryTemplate.RetryPolicy = new NeverRetryPolicy(); retryOperations = retryTemplate; }
protected void SendResponse(RC.IModel channel, Address replyTo, IMessage <byte[]> messageIn) { var message = messageIn; if (BeforeSendReplyPostProcessors != null) { var processors = BeforeSendReplyPostProcessors; IMessage postProcessed = message; foreach (var postProcessor in processors) { postProcessed = postProcessor.PostProcessMessage(postProcessed); } message = postProcessed as IMessage <byte[]>; if (message == null) { throw new InvalidOperationException("A BeforeSendReplyPostProcessors failed to return IMessage<byte[]>"); } } PostProcessChannel(channel, message); try { _logger?.LogDebug("Publishing response to exchange = [{exchange}], routingKey = [{routingKey}]", replyTo.ExchangeName, replyTo.RoutingKey); if (RetryTemplate == null) { DoPublish(channel, replyTo, message); } else { var messageToSend = message; RetryTemplate.Execute <object>( ctx => { DoPublish(channel, replyTo, messageToSend); return(null); }, ctx => { if (RecoveryCallback != null) { ctx.SetAttribute(SendRetryContextAccessor.MESSAGE, messageToSend); ctx.SetAttribute(SendRetryContextAccessor.ADDRESS, replyTo); RecoveryCallback.Recover(ctx); return(null); } else { throw RabbitExceptionTranslator.ConvertRabbitAccessException(ctx.LastException); } }); } } catch (Exception ex) { throw RabbitExceptionTranslator.ConvertRabbitAccessException(ex); } }
protected void SendResponse(IModel channel, Address replyTo, Message messageIn) { var message = messageIn; if (BeforeSendReplyPostProcessors != null) { var processors = BeforeSendReplyPostProcessors; foreach (var postProcessor in processors) { message = postProcessor.PostProcessMessage(message); } } PostProcessChannel(channel, message); try { _logger?.LogDebug("Publishing response to exchange = [" + replyTo.ExchangeName + "], routingKey = [" + replyTo.RoutingKey + "]"); if (RetryTemplate == null) { DoPublish(channel, replyTo, message); } else { var messageToSend = message; RetryTemplate.Execute <object>( ctx => { DoPublish(channel, replyTo, messageToSend); return(null); }, ctx => { if (RecoveryCallback != null) { ctx.SetAttribute(SendRetryContextAccessor.MESSAGE, messageToSend); ctx.SetAttribute(SendRetryContextAccessor.ADDRESS, replyTo); RecoveryCallback.Recover(ctx); return(null); } else { throw RabbitExceptionTranslator.ConvertRabbitAccessException(ctx.LastException); } }); } } catch (Exception ex) { throw RabbitExceptionTranslator.ConvertRabbitAccessException(ex); } }
public void Init() { if (RetryTemplate != null && ErrorChannel != null) { throw new InvalidOperationException( "Cannot have an 'errorChannel' property when a 'RetryTemplate' is " + "provided; use an 'ErrorMessageSendingRecoverer' in the 'recoveryCallback' property to " + "send an error message when retries are exhausted"); } var messageListener = new Listener(this); if (RetryTemplate != null) { RetryTemplate.RegisterListener(messageListener); } _messageListenerContainer.MessageListener = (m) => messageListener.Accept(m); }
public override bool Poll(IMessageHandler handler, Type type) { var message = Receive(type); if (message == null) { return(false); } var ackCallback = StaticMessageHeaderAccessor.GetAcknowledgmentCallback(message); try { if (RetryTemplate == null) { Handle(message, handler); } else { RetryTemplate.Execute((ctx) => Handle(message, handler), _recoveryCallback); } return(true); } catch (MessagingException e) { if (RetryTemplate == null && !ShouldRequeue(e)) { _messagingTemplate.Send(ErrorChannel, ErrorMessageStrategy.BuildErrorMessage(e, _attributesHolder.Value)); return(true); } else if (!ackCallback.IsAcknowledged && ShouldRequeue(e)) { AckUtils.Requeue(ackCallback); return(true); } else { AckUtils.AutoNack(ackCallback); } if (e.FailedMessage.Equals(message)) { throw; } throw new MessageHandlingException(message, e); } catch (Exception e) { AckUtils.AutoNack(ackCallback); if (e is MessageHandlingException && ((MessageHandlingException)e).FailedMessage.Equals(message)) { throw; } throw new MessageHandlingException(message, e); } finally { AckUtils.AutoAck(ackCallback); } }