public FirstLevelRetries(int maxRetries, IManageMessageFailures failureManager, CriticalError criticalError, BusNotifications busNotifications)
{
this.maxRetries = maxRetries;
this.failureManager = failureManager;
this.criticalError = criticalError;
notifications = busNotifications;
}
static RepeatedFailuresOverTimeCircuitBreaker SetupCircuitBreaker(CriticalError criticalError, TimeSpan timeToWaitBeforeTriggering, TimeSpan delayAfterFailure)
{
return(new RepeatedFailuresOverTimeCircuitBreaker("SqlTransportConnectivity",
timeToWaitBeforeTriggering,
ex => criticalError.Raise("Repeated failures when communicating with SQL",
ex), delayAfterFailure));
}
public FirstLevelRetries(int maxRetries, IManageMessageFailures failureManager, CriticalError criticalError, BusNotifications busNotifications)
{
this.maxRetries = maxRetries;
this.failureManager = failureManager;
this.criticalError = criticalError;
notifications = busNotifications;
}
public Task Init(Func<PushContext, Task> pipe, CriticalError criticalError, PushSettings settings)
{
pipeline = pipe;
path = BaseDirectoryBuilder.BuildBasePath(settings.InputQueue);
purgeOnStartup = settings.PurgeOnStartup;
return TaskEx.CompletedTask;
}
static RepeatedFailuresOverTimeCircuitBreaker SetupCircuitBreaker(CriticalError criticalError, TimeSpan timeToWaitBeforeTriggering, TimeSpan delayAfterFailure)
{
return new RepeatedFailuresOverTimeCircuitBreaker("SqlTransportConnectivity",
timeToWaitBeforeTriggering,
ex => criticalError.Raise("Repeated failures when communicating with SQL",
ex), delayAfterFailure);
}
public CleanupTask(Table table, CriticalError criticalError,
Func <CancellationToken, Task <SqlConnection> > connectionBuilder)
{
this.table = table;
this.criticalError = criticalError;
this.connectionBuilder = connectionBuilder;
}
public Task Init(Func <PushContext, Task> pipe, CriticalError criticalError, PushSettings settings)
{
pipeline = pipe;
path = BaseDirectoryBuilder.BuildBasePath(settings.InputQueue);
purgeOnStartup = settings.PurgeOnStartup;
return(TaskEx.CompletedTask);
}
public EventDispatcher(IDocumentStore store, IBus bus, CriticalError criticalError, Settings settings, IEnumerable <IEventPublisher> eventPublishers)
{
this.store = store;
this.bus = bus;
this.criticalError = criticalError;
this.settings = settings;
this.eventPublishers = eventPublishers;
}
public GuardNoActivityBehavior(CriticalError criticalError, TimeSpan noActivityDuration)
{
NoActivityDuration = noActivityDuration;
CriticalError = criticalError;
InactivityTimer = new Timer(s => HandleTimerCallback());
last = DateTime.UtcNow;
HandleTimerCallback();
}
public Task Init(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, PushSettings settings)
{
_onError = onError;
_onMessage = onMessage;
_purgeOnStartup = settings.PurgeOnStartup;
_criticalError = criticalError;
return(Task.CompletedTask);
}
void InvokeCriticalError(CriticalError criticalError, string errorMessage, Exception exception)
{
#region InvokeCriticalError
// 'criticalError' is an instance of the NServiceBus.CriticalError class
// This instance can be resolved from the container.
criticalError.Raise(errorMessage, exception);
#endregion
}
public ClientOutboxCleaner(ITimerService timerService, IClientOutboxStorage clientOutboxStorage, IClientOutboxStorageV2 clientOutboxStorageV2, ReadOnlySettings settings, CriticalError criticalError)
{
_timerService = timerService;
_clientOutboxStorage = clientOutboxStorage;
_clientOutboxStorageV2 = clientOutboxStorageV2;
_criticalError = criticalError;
_frequency = settings.GetOrDefault <TimeSpan?>("Persistence.Sql.Outbox.FrequencyToRunDeduplicationDataCleanup") ?? TimeSpan.FromMinutes(1);
_maxAge = settings.GetOrDefault <TimeSpan?>("Persistence.Sql.Outbox.TimeToKeepDeduplicationData") ?? TimeSpan.FromDays(7);
}
void InvokeCriticalError(CriticalError criticalError, string errorMessage, Exception exception)
{
#region InvokeCriticalError
// 'criticalError' is an instance of NServiceBus.CriticalError
// This instance can be resolved from dependency injection.
criticalError.Raise(errorMessage, exception);
#endregion
}
public async Task Pushes_received_message_into_pipeline()
{
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
await TestUtility.Delete("sales");
var settings = new SettingsHolder();
settings.Set("NServiceBus.SharedQueue", "sales");
new DefaultConfigurationValues().Apply(settings);
// setting up the environment
var container = new TransportPartsContainer();
var topology = await SetupEndpointOrientedTopology(container, "sales");
// setup the operator
var pump = new MessagePump(topology, container, settings);
var completed = new AsyncManualResetEvent(false);
//var error = new AsyncManualResetEvent(false);
var received = false;
Exception ex = null;
// Dummy CriticalError
var criticalError = new CriticalError(ctx => TaskEx.Completed);
await pump.Init(context =>
{
received = true;
completed.Set();
return(TaskEx.Completed);
}, null, criticalError, new PushSettings("sales", "error", false, TransportTransactionMode.ReceiveOnly));
// execute
pump.Start(new PushRuntimeSettings(1));
// send message to queue
var senderFactory = (MessageSenderCreator)container.Resolve(typeof(MessageSenderCreator));
var sender = await senderFactory.Create("sales", null, "namespaceName");
await sender.Send(new BrokeredMessage());
await completed.WaitAsync(cts.Token).IgnoreCancellation(); // Task.WhenAny(completed.WaitOne(), error.WaitOne());
// validate
Assert.IsTrue(received);
Assert.IsNull(ex);
// cleanup
await pump.Stop();
}
public RoutingInfoCommunicator(SqlDataAccess dataAccess, CriticalError criticalError)
{
this.dataAccess = dataAccess;
circuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker(
name: "Refresh",
timeToWaitBeforeTriggering: TimeSpan.FromMinutes(2),
triggerAction: exception =>
{
criticalError.Raise("Failed to refresh routing info.", exception);
});
}
public AuditQueueImport(IBuilder builder, ISendMessages forwarder, IDocumentStore store, CriticalError criticalError, LoggingSettings loggingSettings, Settings settings, AuditImporter auditImporter)
{
this.builder = builder;
this.forwarder = forwarder;
this.store = store;
this.criticalError = criticalError;
this.loggingSettings = loggingSettings;
this.settings = settings;
this.auditImporter = auditImporter;
enrichers = builder.BuildAll <IEnrichImportedMessages>().Where(e => e.EnrichAudits).ToArray();
}
public Task Init(
Func <MessageContext, Task> onMessage,
Func <ErrorContext, Task <ErrorHandleResult> > onError,
CriticalError criticalError,
PushSettings settings)
{
this.passMessageToNsb = onMessage;
this.letNsbKnowAboutAnError = onError;
this.criticalError = criticalError;
this.nsbSettings = settings;
this.messagePumpName = $"MessagePump-{this.nsbSettings.InputQueue}";
return(Task.CompletedTask);
}
public void Should_throw()
{
var settings = SettingsHolderFactory.BuildWithSerializer();
settings.Set("NServiceBus.SharedQueue", "sales");
DefaultConfigurationValues.Apply(settings);
var pump = new MessagePump(null, null, null, null, settings, "sales");
var criticalError = new CriticalError(ctx => TaskEx.Completed);
const bool purgeOnStartup = true;
Assert.ThrowsAsync <InvalidOperationException>(async() => await pump.Init(context => TaskEx.Completed, null, criticalError, new PushSettings("sales", "error", purgeOnStartup, TransportTransactionMode.SendsAtomicWithReceive)));
}
public void Start()
{
circuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker("TimeoutStorageConnectivity", TimeSpan.FromMinutes(2),
ex =>
CriticalError.Raise("Repeated failures when fetching timeouts from storage, endpoint will be terminated.", ex));
TimeoutManager.TimeoutPushed = TimeoutsManagerOnTimeoutPushed;
SecondsToSleepBetweenPolls = 1;
tokenSource = new CancellationTokenSource();
StartPoller();
}
internal static void SendCriticalError(string message, string source, string stackTrace, string targetSite)
{
var type = PacketType.CriticalError;
BinaryFormatter formatter = new BinaryFormatter();
Client.serializer.Serialize(Client.ClientStream, type);
var criticalError = new CriticalError();
criticalError.Message = message;
criticalError.Source = source;
criticalError.StackTrace = stackTrace;
criticalError.TargetSite = targetSite;
Client.serializer.Serialize(Client.ClientStream, criticalError);
}
public Task Init(
Func <MessageContext, Task> onMessage,
Func <ErrorContext, Task <ErrorHandleResult> > onError,
CriticalError criticalError,
PushSettings settings)
{
pushSettings = settings;
this.criticalError = criticalError;
this.onError = onError;
this.onMessage = onMessage;
inputQueue = settings.InputQueue;
return(Task.CompletedTask);
}
public Task Init(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, PushSettings settings)
{
InMemoryDatabase.CreateQueueIfNecessary(settings.InputQueue);
_queue = InMemoryDatabase.GetQueue(settings.InputQueue);
if (_queue == null)
{
throw new InvalidProgramException($"Unable to get or add the queue '{settings.InputQueue}'.");
}
_purgeOnStartup = settings.PurgeOnStartup;
this._onMessage = onMessage;
this._onError = onError;
this._criticalError = criticalError;
return(Task.CompletedTask);
}
public Task Init(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, PushSettings settings)
{
this.onMessage = onMessage;
this.onError = onError;
this.settings = settings;
this.criticalError = criticalError;
circuitBreaker = new MessagePumpConnectionFailedCircuitBreaker($"'{settings.InputQueue} MessagePump'", timeToWaitBeforeTriggeringCircuitBreaker, criticalError);
if (settings.PurgeOnStartup)
{
queuePurger.Purge(settings.InputQueue);
}
return(Task.CompletedTask);
}
public ErrorQueueImport(IBuilder builder, ISendMessages forwarder, IDocumentStore store, IBus bus, CriticalError criticalError, LoggingSettings loggingSettings, Settings settings, BodyStorageFeature.BodyStorageEnricher bodyStorageEnricher)
{
this.builder = builder;
this.forwarder = forwarder;
this.store = store;
this.bus = bus;
this.criticalError = criticalError;
this.loggingSettings = loggingSettings;
this.settings = settings;
this.bodyStorageEnricher = bodyStorageEnricher;
enrichers = builder.BuildAll <IEnrichImportedMessages>().Where(e => e.EnrichErrors).ToArray();
var failedEnrichers = builder.BuildAll <IFailedMessageEnricher>().ToArray();
failedMessageFactory = new FailedMessageFactory(failedEnrichers);
}
public Task Init(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, PushSettings settings)
{
if (settings.PurgeOnStartup)
{
throw new Exception("Azure Service Bus transport doesn't support PurgeOnStartup behavior");
}
this.onMessage = messageReceivedMiddleware == null ? onMessage : messageContext => messageReceivedMiddleware(messageContext, onMessage);
this.onError = onError;
this.criticalError = criticalError;
pushSettings = settings;
circuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker($"'{settings.InputQueue}'", timeToWaitBeforeTriggeringCircuitBreaker, criticalError);
return(Task.CompletedTask);
}
/// <summary>
/// <see cref="IStartableBus.Start()"/>
/// </summary>
public IBus Start()
{
LicenseManager.PromptUserForLicenseIfTrialHasExpired();
if (started)
{
return(this);
}
lock (startLocker)
{
if (started)
{
return(this);
}
AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
if (!DoNotStartTransport)
{
Transport.StartedMessageProcessing += TransportStartedMessageProcessing;
Transport.TransportMessageReceived += TransportMessageReceived;
Transport.FinishedMessageProcessing += TransportFinishedMessageProcessing;
Transport.Start(InputAddress);
}
started = true;
}
satelliteLauncher = new SatelliteLauncher(Builder);
satelliteLauncher.Start();
ProcessStartupItems(
Builder.BuildAll <IWantToRunWhenBusStartsAndStops>().ToList(),
toRun =>
{
toRun.Start();
thingsRanAtStartup.Add(toRun);
Log.DebugFormat("Started {0}.", toRun.GetType().AssemblyQualifiedName);
},
ex => CriticalError.Raise("Startup task failed to complete.", ex),
startCompletedEvent);
return(this);
}
public void Should_throw()
{
var container = new TransportPartsContainer();
container.Register <TopologyOperator>();
var settings = new SettingsHolder();
settings.Set("NServiceBus.SharedQueue", "sales");
new DefaultConfigurationValues().Apply(settings);
container.Register <ReadOnlySettings>(() => settings);
var pump = new MessagePump(null, container, settings);
var criticalError = new CriticalError(ctx => TaskEx.Completed);
const bool purgeOnStartup = true;
Assert.ThrowsAsync <InvalidOperationException> (async() => await pump.Init(context => TaskEx.Completed, null, criticalError, new PushSettings("sales", "error", purgeOnStartup, TransportTransactionMode.SendsAtomicWithReceive)));
}
public ServiceControlBackend(ISendMessages messageSender, Configure configure, CriticalError criticalError)
{
this.configure = configure;
this.criticalError = criticalError;
this.messageSender = messageSender;
serializer = new JsonMessageSerializer(new SimpleMessageMapper());
serviceControlBackendAddress = GetServiceControlAddress();
VerifyIfServiceControlQueueExists();
circuitBreaker =
new RepeatedFailuresOverTimeCircuitBreaker("ServiceControlConnectivity", TimeSpan.FromMinutes(2),
ex =>
criticalError.Raise(
"This endpoint is repeatedly unable to contact the ServiceControl backend to report endpoint information. You have the ServiceControl plugins installed in your endpoint. However, please ensure that the Particular ServiceControl service is installed on this machine, " +
"or if running ServiceControl on a different machine, then ensure that your endpoint's app.config / web.config, AppSettings has the following key set appropriately: ServiceControl/Queue. \r\n" +
@"For example: <add key=""ServiceControl/Queue"" value=""particular.servicecontrol@machine""/>" +
"\r\n", ex));
}
public async Task Init(Func <MessageContext, Task> onMessage, Func <ErrorContext, Task <ErrorHandleResult> > onError, CriticalError criticalError, PushSettings settings)
{
this.criticalError = criticalError;
this.onError = onError;
this.onMessage = onMessage;
try
{
subscriberClient = await SubscriberClient.CreateAsync()
.ConfigureAwait(false);
subscriptionName = new SubscriptionName(projectId, settings.InputQueue);
await subscriberClient.CreateSubscriptionAsync(subscriptionName, new TopicName(projectId, settings.InputQueue), pushConfig : null, ackDeadlineSeconds : 60)
.ConfigureAwait(false);
}
catch (RpcException e) when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
}
}
public void SetUp()
{
tokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(60));
completed = new AsyncManualResetEvent(false);
container = new TransportPartsContainer();
var settings = new SettingsHolder();
settings.Set("NServiceBus.SharedQueue", SourceQueueName);
criticalError = new CriticalError(ctx => TaskEx.Completed);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.SendViaReceiveQueue(true);
SetupAsync(container, settings).GetAwaiter().GetResult();
dispatcher = (IDispatchMessages)container.Resolve(typeof(IDispatchMessages));
timeToWaitBeforeTriggeringTheCircuitBreaker = TimeSpan.FromSeconds(5);
pump = new MessagePump(topology, container, settings, timeToWaitBeforeTriggeringTheCircuitBreaker);
}
static RepeatedFailuresOverTimeCircuitBreaker SetupCircuitBreaker(CriticalError criticalError)
{
var timeToWaitBeforeTriggering = TimeSpan.FromMinutes(2);
var timeToWaitBeforeTriggeringOverride = ConfigurationManager.AppSettings["NServiceBus/KafkaDequeueStrategy/TimeToWaitBeforeTriggering"];
if (!string.IsNullOrEmpty(timeToWaitBeforeTriggeringOverride))
{
timeToWaitBeforeTriggering = TimeSpan.Parse(timeToWaitBeforeTriggeringOverride);
}
var delayAfterFailure = TimeSpan.FromSeconds(5);
var delayAfterFailureOverride = ConfigurationManager.AppSettings["NServiceBus/KafkaDequeueStrategy/DelayAfterFailure"];
if (!string.IsNullOrEmpty(delayAfterFailureOverride))
{
delayAfterFailure = TimeSpan.Parse(delayAfterFailureOverride);
}
return(new RepeatedFailuresOverTimeCircuitBreaker("KafkaConnectivity",
timeToWaitBeforeTriggering,
ex => criticalError.Raise("Repeated failures when communicating with the broker",
ex), delayAfterFailure));
}
/// <summary>
/// Creates an instance of <see cref="MsmqDequeueStrategy" />.
/// </summary>
/// <param name="configure">Configure</param>
/// <param name="criticalError">CriticalError</param>
/// <param name="unitOfWork">MsmqUnitOfWork</param>
public MsmqDequeueStrategy(Configure configure, CriticalError criticalError, MsmqUnitOfWork unitOfWork)
{
this.configure = configure;
this.criticalError = criticalError;
this.unitOfWork = unitOfWork;
}
public MsmqReceiver(Configure configure, CriticalError criticalError, IPublishMessages publisher)
{
this.configure = configure;
this.criticalError = criticalError;
this.publisher = publisher;
}
public Task Init(Func<MessageContext, Task> onMessage, Func<ErrorContext, Task<ErrorHandleResult>> onError, CriticalError criticalError, PushSettings settings)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates an instance of <see cref="MsmqDequeueStrategy" />.
/// </summary>
/// <param name="configure">Configure</param>
/// <param name="criticalError">CriticalError</param>
/// <param name="unitOfWork">MsmqUnitOfWork</param>
public MsmqDequeueStrategy(Configure configure, CriticalError criticalError, MsmqUnitOfWork unitOfWork)
{
this.configure = configure;
this.criticalError = criticalError;
this.unitOfWork = unitOfWork;
}
// the CriticalError instance will be injected at runtime
public MyService(CriticalError criticalError)
{
this.criticalError = criticalError;
}
public FirstLevelRetries(int maxRetries, IManageMessageFailures failureManager, CriticalError criticalError)
{
this.maxRetries = maxRetries;
this.failureManager = failureManager;
this.criticalError = criticalError;
}
public AzureServiceBusDequeueStrategy(ITopology topology, CriticalError criticalError)
{
this.topology = topology;
this.criticalError = criticalError;
circuitBreaker = new RepeatedFailuresOverTimeCircuitBreaker("AzureServiceBusDequeueStrategy", TimeSpan.FromSeconds(30), ex => criticalError.Raise("Failed to receive message from Azure ServiceBus.", ex));
}
public OutboxCleaner(OutboxPersister outboxPersister, CriticalError criticalError)
{
this.outboxPersister = outboxPersister;
this.criticalError = criticalError;
}
public void SetCriticalError(CriticalError criticalError)
{
}
static RepeatedFailuresOverTimeCircuitBreaker SetupCircuitBreaker(CriticalError criticalError)
{
var timeToWaitBeforeTriggering = TimeSpan.FromMinutes(2);
var timeToWaitBeforeTriggeringOverride = ConfigurationManager.AppSettings["NServiceBus/RabbitMqDequeueStrategy/TimeToWaitBeforeTriggering"];
if (!string.IsNullOrEmpty(timeToWaitBeforeTriggeringOverride))
{
timeToWaitBeforeTriggering = TimeSpan.Parse(timeToWaitBeforeTriggeringOverride);
}
var delayAfterFailure = TimeSpan.FromSeconds(5);
var delayAfterFailureOverride = ConfigurationManager.AppSettings["NServiceBus/RabbitMqDequeueStrategy/DelayAfterFailure"];
if (!string.IsNullOrEmpty(delayAfterFailureOverride))
{
delayAfterFailure = TimeSpan.Parse(delayAfterFailureOverride);
}
return new RepeatedFailuresOverTimeCircuitBreaker("RabbitMqConnectivity",
timeToWaitBeforeTriggering,
ex => criticalError.Raise("Repeated failures when communicating with the broker",
ex), delayAfterFailure);
}
