static async Task <IRawEndpointInstance> StartMonitor() { var queueMonitorContext = new DefaultMetricsContext("QueueLengthMonitor"); new MetricsConfig(queueMonitorContext) .WithHttpEndpoint("http://localhost:7777/QueueLengthMonitor/") .WithReporting(r => { r.WithReport( new PerformanceCounterReporter(x => new CounterInstanceName("Queue Length", x.MetricName)), TimeSpan.FromSeconds(5), Filter.New.WhereContext(c => c == "QueueLengthMonitor" || c == "QueueState")); }); var monitor = new Monitor(queueMonitorContext, new QueueLength()); var config = RawEndpointConfiguration.Create("QueueLengthMonitor", monitor.OnMessage); config.LimitMessageProcessingConcurrencyTo(1); config.UseTransport <MsmqTransport>(); //config.UseTransport<RabbitMQTransport>().ConnectionString("host=localhost"); config.SendFailedMessagesTo("error"); var endpoint = await RawEndpoint.Start(config); return(endpoint); }
public virtual async Task Run(string forwardingBatchId, Predicate <MessageContext> filter, CancellationToken cancellationToken, int?expectedMessageCount) { IReceivingRawEndpoint processor = null; CancellationTokenRegistration?registration = null; try { shouldProcess = filter; targetMessageCount = expectedMessageCount; actualMessageCount = 0; if (Log.IsDebugEnabled) { Log.DebugFormat("Starting receiver"); } var config = createEndpointConfiguration(); syncEvent = new TaskCompletionSource <bool>(); stopCompletionSource = new TaskCompletionSource <bool>(); registration = cancellationToken.Register(() => { Task.Run(() => syncEvent.TrySetResult(true), CancellationToken.None).Ignore(); }); processor = await RawEndpoint.Start(config).ConfigureAwait(false); Log.Info($"Forwarder for batch {forwardingBatchId} started receiving messages from {processor.TransportAddress}."); if (!expectedMessageCount.HasValue) { if (Log.IsDebugEnabled) { Log.Debug("Running in timeout mode. Starting timer."); } timer.Change(TimeSpan.FromSeconds(45), Timeout.InfiniteTimeSpan); } } finally { if (Log.IsDebugEnabled) { Log.DebugFormat($"Waiting for forwarder for batch {forwardingBatchId} to finish."); } await syncEvent.Task.ConfigureAwait(false); registration?.Dispose(); if (processor != null) { await processor.Stop().ConfigureAwait(false); } Log.Info($"Forwarder for batch {forwardingBatchId} finished forwarding all messages."); await Task.Run(() => stopCompletionSource.TrySetResult(true), CancellationToken.None).ConfigureAwait(false); } if (endedPrematurely || cancellationToken.IsCancellationRequested) { throw new Exception("We are in the process of shutting down. Safe to ignore."); } }
internal static async Task <(IReceivingRawEndpoint, StateStore)> SetupEndpoint(Action <Guid, Message, Message[]> messageProcessed) { var storageTable = await PrepareStorageTable(); var stateStore = new StateStore(storageTable); var handlerInvoker = new HandlerInvoker(stateStore); var endpointConfiguration = RawEndpointConfiguration.Create( endpointName: EndpointName, onMessage: async(c, d) => { var message = Serializer.Deserialize(c.Body, c.Headers); var outputMessages = await handlerInvoker.Process(message); var runId = Guid.Parse(c.Headers["Message.RunId"]); messageProcessed(runId, message, outputMessages); await d.Send(outputMessages, runId); }, poisonMessageQueue: "error"); endpointConfiguration.UseTransport <LearningTransport>() .Transactions(TransportTransactionMode.ReceiveOnly); var defaultFactory = LogManager.Use <DefaultFactory>(); defaultFactory.Level(LogLevel.Debug); var endpoint = await RawEndpoint.Start(endpointConfiguration); return(endpoint, stateStore); }
async Task Run <T, I>(CancellationToken token) where I : AbstractIndexCreationTask, new() { var config = rawEndpointFactory.CreateFailedAuditsSender("ImportFailedAudits"); var endpoint = await RawEndpoint.Start(config).ConfigureAwait(false); await auditIngestor.Initialize(endpoint).ConfigureAwait(false); var succeeded = 0; var failed = 0; using (var session = store.OpenAsyncSession()) { var query = session.Query <T, I>(); using (var ie = await session.Advanced.StreamAsync(query, token) .ConfigureAwait(false)) { while (!token.IsCancellationRequested && await ie.MoveNextAsync().ConfigureAwait(false)) { FailedTransportMessage dto = ((dynamic)ie.Current.Document).Message; try { var messageContext = new MessageContext(dto.Id, dto.Headers, dto.Body, EmptyTransaction, EmptyTokenSource, EmptyContextBag); var taskCompletionSource = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously); messageContext.SetTaskCompletionSource(taskCompletionSource); await auditIngestor.Ingest(new List <MessageContext> { messageContext }).ConfigureAwait(false); await taskCompletionSource.Task.ConfigureAwait(false); await store.AsyncDatabaseCommands.DeleteAsync(ie.Current.Key, null, token) .ConfigureAwait(false); succeeded++; if (Logger.IsDebugEnabled) { Logger.Debug($"Successfully re-imported failed audit message {dto.Id}."); } } catch (OperationCanceledException) { // no-op } catch (Exception e) { Logger.Error($"Error while attempting to re-import failed audit message {dto.Id}.", e); failed++; } } } } Logger.Info($"Done re-importing failed audits. Successfully re-imported {succeeded} messages. Failed re-importing {failed} messages."); if (failed > 0) { Logger.Warn($"{failed} messages could not be re-imported. This could indicate a problem with the data. Contact Particular support if you need help with recovering the messages."); } }
static async Task Main() { Console.Title = "Case00041163.OccasionalSubscriber"; var endpointConfiguration = RawEndpointConfiguration.Create(Console.Title, (context, messages) => Task.CompletedTask, "error"); endpointConfiguration.UseTransport <MsmqTransport>(); var endpointInstance = await RawEndpoint.Start(endpointConfiguration) .ConfigureAwait(false); var subscriptionMessage = ControlMessageFactory.Create(MessageIntentEnum.Subscribe); subscriptionMessage.Headers[Headers.SubscriptionMessageType] = typeof(MyEvent).AssemblyQualifiedName; subscriptionMessage.Headers[Headers.ReplyToAddress] = "Case00041163.OccasionalSubscriber@FAKEPC"; subscriptionMessage.Headers[Headers.SubscriberTransportAddress] = "Case00041163.OccasionalSubscriber@FAKEPC"; subscriptionMessage.Headers[Headers.SubscriberEndpoint] = "Case00041163.OccasionalSubscriber"; subscriptionMessage.Headers[Headers.TimeSent] = DateTimeExtensions.ToWireFormattedString(DateTime.UtcNow); subscriptionMessage.Headers[Headers.NServiceBusVersion] = "5.6.4"; var operation = new TransportOperation(subscriptionMessage, new UnicastAddressTag("Case00041163.Publisher")); await endpointInstance.Dispatch(new TransportOperations(operation), new TransportTransaction(), new ContextBag()).ConfigureAwait(false); await endpointInstance.Stop().ConfigureAwait(false); }
RawEndpointConfiguration PrepareConfig(string inputQueue, string poisonMessageQueueName, Action <TransportExtensions <T> > transportCustomization, Func <MessageContext, IDispatchMessages, Task> onMessage, PoisonMessageHandling poisonMessageHandling, int?maximumConcurrency, int immediateRetries, int delayedRetries, int circuitBreakerThreshold, bool autoCreateQueue, string autoCreateQueueIdentity) { var circuitBreaker = new RepeatedFailuresCircuitBreaker(inputQueue, circuitBreakerThreshold, e => { logger.Error($"Persistent error while processing messages in {inputQueue}. Entering throttled mode.", e); Task.Run(async() => { await transitionSemaphore.WaitAsync().ConfigureAwait(false); try { var oldEndpoint = endpoint; var throttledConfig = PrepareThrottledConfig(inputQueue, poisonMessageQueueName, transportCustomization, onMessage, poisonMessageHandling, maximumConcurrency, immediateRetries, circuitBreakerThreshold, delayedRetries); var newEndpoint = await RawEndpoint.Start(throttledConfig).ConfigureAwait(false); endpoint = newEndpoint; await oldEndpoint.Stop().ConfigureAwait(false); } catch (Exception ex) { logger.Error("Error when entering throttled mode", ex); } finally { transitionSemaphore.Release(); } }); }); var regularConfig = RawEndpointConfiguration.Create(inputQueue, async(context, dispatcher) => { await onMessage(context, dispatcher).ConfigureAwait(false); circuitBreaker.Success(); }, poisonMessageQueueName); regularConfig.CustomErrorHandlingPolicy(new RegularModePolicy(inputQueue, circuitBreaker, poisonMessageHandling, immediateRetries, delayedRetries)); Task onCriticalError(ICriticalErrorContext context) { logger.Fatal($"The receiver for queue {inputQueue} has encountered a severe error that is likely related to the connectivity with the broker or the broker itself."); return(Task.CompletedTask); } regularConfig.Settings.Set("onCriticalErrorAction", (Func <ICriticalErrorContext, Task>)onCriticalError); var transport = regularConfig.UseTransport <T>(); transportCustomization(transport); if (autoCreateQueue) { regularConfig.AutoCreateQueue(autoCreateQueueIdentity); } if (maximumConcurrency.HasValue) { regularConfig.LimitMessageProcessingConcurrencyTo(maximumConcurrency.Value); } return(regularConfig); }
public virtual async Task Run(Predicate <MessageContext> filter, CancellationToken cancellationToken, int?expectedMessageCount = null) { IReceivingRawEndpoint processor = null; CancellationTokenRegistration?registration = null; try { Log.DebugFormat("Started. Expectected message count {0}", expectedMessageCount); if (expectedMessageCount.HasValue && expectedMessageCount.Value == 0) { return; } shouldProcess = filter; targetMessageCount = expectedMessageCount; actualMessageCount = 0; Log.DebugFormat("Starting receiver"); var config = createEndpointConfiguration(); syncEvent = new TaskCompletionSource <bool>(); stopCompletionSource = new TaskCompletionSource <bool>(); registration = cancellationToken.Register(() => { Task.Run(() => syncEvent.TrySetResult(true), CancellationToken.None).Ignore(); }); processor = await RawEndpoint.Start(config).ConfigureAwait(false); if (!expectedMessageCount.HasValue) { Log.Debug("Running in timeout mode. Starting timer"); timer.Change(TimeSpan.FromSeconds(45), Timeout.InfiniteTimeSpan); } Log.InfoFormat("{0} started", GetType().Name); } finally { Log.DebugFormat("Waiting for {0} finish", GetType().Name); await syncEvent.Task.ConfigureAwait(false); registration?.Dispose(); if (processor != null) { await processor.Stop().ConfigureAwait(false); } await Task.Run(() => stopCompletionSource.TrySetResult(true), CancellationToken.None).ConfigureAwait(false); Log.DebugFormat("{0} finished", GetType().Name); } if (endedPrematurelly || cancellationToken.IsCancellationRequested) { throw new Exception("We are in the process of shutting down. Safe to ignore."); } }
/// <summary> /// Starts the endpoint. /// </summary> public async Task Start() { var outConfig = RawEndpointConfiguration.Create(storageQueueName, OnOutgoingMessage, poisonMessageQueue); outConfig.LimitMessageProcessingConcurrencyTo(1); transportCustomization(outConfig.UseTransport <T>()); outConfig.CustomErrorHandlingPolicy(new RetryForeverPolicy()); outConfig.AutoCreateQueue(); outEndpoint = await RawEndpoint.Start(outConfig).ConfigureAwait(false); }
public override async Task Start(CancellationToken token) { var config = RawEndpointConfiguration.Create("poison", OnMessage, "poison"); config.AutoCreateQueue(); config.CustomErrorHandlingPolicy(new IgnoreErrorsPolicy()); var transport = config.UseTransport <TestTransport>(); transportConfiguration(transport); endpoint = await RawEndpoint.Start(config); }
static async Task Main(string[] args) { var senderConfig = RawEndpointConfiguration.Create("DummyHandler", OnMessage, "error"); var transport = senderConfig.UseTransport <AzureServiceBusTransport>(); transport.ConnectionString(Environment.GetEnvironmentVariable("AzureServiceBus_ConnectionString")); senderConfig.LimitMessageProcessingConcurrencyTo(10); var sender = await RawEndpoint.Start(senderConfig).ConfigureAwait(false); Console.ReadLine(); }
RawEndpointConfiguration PrepareThrottledConfig(string inputQueue, string poisonMessageQueueName, Action <TransportExtensions <T> > transportCustomization, Func <MessageContext, IDispatchMessages, Task> onMessage, PoisonMessageHandling poisonMessageHandling, int?maximumConcurrency, int immediateRetries, int delayedRetries, int circuitBreakerThreshold) { var switchedBack = false; var throttledConfig = RawEndpointConfiguration.Create(inputQueue, async(context, dispatcher) => { await onMessage(context, dispatcher); if (switchedBack) { return; } await transitionSemaphore.WaitAsync().ConfigureAwait(false); Task.Run(async() => { logger.Info("Exiting throttled mode."); try { var oldEndpoint = endpoint; var regularConfig = PrepareConfig(inputQueue, poisonMessageQueueName, transportCustomization, onMessage, poisonMessageHandling, maximumConcurrency, immediateRetries, delayedRetries, circuitBreakerThreshold, false, null); var newEndpoint = await RawEndpoint.Start(regularConfig).ConfigureAwait(false); endpoint = newEndpoint; await oldEndpoint.Stop().ConfigureAwait(false); } catch (Exception e) { logger.Error("Error when exiting throttled mode", e); } finally { transitionSemaphore.Release(); } }).Ignore(); switchedBack = true; }, poisonMessageQueueName); throttledConfig.CustomErrorHandlingPolicy(new ThrottledModePolicy(inputQueue, immediateRetries)); Task onCriticalError(ICriticalErrorContext context) { logger.Fatal($"The receiver for queue {inputQueue} has encountered a severe error that is likely related to the connectivity with the broker or the broker itself."); return(Task.CompletedTask); } throttledConfig.Settings.Set("onCriticalErrorAction", (Func <ICriticalErrorContext, Task>)onCriticalError); var transport = throttledConfig.UseTransport <T>(); transportCustomization(transport); throttledConfig.LimitMessageProcessingConcurrencyTo(1); return(throttledConfig); }
public static async Task InitServerEndpoint(string endpointName) { if (serverEndpoint == null) { var senderConfig = RawEndpointConfiguration.Create( endpointName: endpointName, onMessage: OnMessage, poisonMessageQueue: "error"); senderConfig.UseTransport <MsmqTransport>(); serverEndpoint = await RawEndpoint.Start(senderConfig) .ConfigureAwait(false); } }
public async static Task InitSubTwoEndpoint(string endpointName, Func <MessageContext, IDispatchMessages, Task> func) { if (subscriber2Endpoint == null) { var senderConfig = RawEndpointConfiguration.Create( endpointName: endpointName, onMessage: func, poisonMessageQueue: "error"); senderConfig.UseTransport <MsmqTransport>(); senderConfig.AutoCreateQueue(); subscriber2Endpoint = await RawEndpoint.Start(senderConfig) .ConfigureAwait(false); } }
public async Task StartAsync(CancellationToken cancellationToken) { var endpointConfiguration = RawEndpointConfiguration.Create(attribute.QueueName, OnMessage, poisonMessageQueue); if (Directory.Exists(nsbLogPath)) { LogManager.Use <DefaultFactory>().Directory(nsbLogPath); } var connectionString = AmbientConnectionStringProvider.Instance.GetConnectionString(attribute.Connection); endpointConfiguration.UseTransport <AzureStorageQueueTransport>().ConnectionString(connectionString); endpointConfiguration.DefaultErrorHandlingPolicy(poisonMessageQueue, immediateRetryCount); endpoint = await RawEndpoint.Start(endpointConfiguration).ConfigureAwait(false); }
static async Task <List <MessageContext> > RunResubscriberOnce(params MessageContext[] input) { await Cleanup("ResubscriberTest", "ResubscriberTest.Resubscriber", "poison").ConfigureAwait(false); var done = new TaskCompletionSource <bool>(); var output = new List <MessageContext>(); var listenerConfig = RawEndpointConfiguration.Create("ResubscriberTest", (context, dispatcher) => { if (context.Headers[Headers.SubscriptionMessageType] == "stop") { done.SetResult(true); } else { output.Add(context); } return(Task.CompletedTask); }, "poison"); listenerConfig.UseTransport <MsmqTransport>(); listenerConfig.LimitMessageProcessingConcurrencyTo(1); listenerConfig.AutoCreateQueue(); var listener = await RawEndpoint.Start(listenerConfig); var resubscriber = await Resubscriber <MsmqTransport> .Create("ResubscriberTest", TimeSpan.FromSeconds(3), t => { }); foreach (var messageContext in input) { await resubscriber.InterceptMessageForwarding("ResubscriberTest", messageContext, NoopDispatch, NoopForward).ConfigureAwait(false); } await resubscriber.InterceptMessageForwarding("ResubscriberTest", CreateTerminatingContext(), NoopDispatch, NoopForward); await resubscriber.Start(); await done.Task; await resubscriber.Stop(); await listener.Stop(); return(output); }
internal async Task Start(Dictionary <string, QueueInfo> queues, string errorQueue) { instances = new List <IRawEndpointInstance>(); var barrier = new TaskCompletionSource <bool>(); foreach (var queueInfo in queues) { var instance = await RawEndpoint.Start(CreateEndpointConfig(queueInfo, barrier.Task, errorQueue)).ConfigureAwait(false); instances.Add(instance); foreach (var catalog in queueInfo.Value.Catalogs) { endpointsByCatalog.Add(catalog, instance); } } barrier.SetResult(true); }
public async Task <IEndpointInstance> StartOutbox() { var destinationEndpoint = await RawEndpoint.Start(_destinationEndpointConfiguration).ConfigureAwait(false); // Setup the message forwarder var forwarder = new MessageForwarder(_destinationEndpointName, destinationEndpoint); _onMessage = forwarder.OnMessage; var forwarderEndpoint = await RawEndpoint.Start(_forwarderEndpointConfiguration).ConfigureAwait(false); foreach (var configAction in _outboxEndpointConfigurationActions) { configAction.Invoke(_outboxEndpointConfiguration); } _unicastRoutingTable.AddOrReplaceRoutes("EndpointConfiguration", _configRouteTableEntries); var outboxEndpoint = await Endpoint.Start(_outboxEndpointConfiguration).ConfigureAwait(false); return(new WebOutboxEndpoint(outboxEndpoint, forwarderEndpoint, destinationEndpoint)); }
static async Task Start() { #region Configuration var senderConfig = RawEndpointConfiguration.Create( endpointName: "EndpointName", onMessage: OnMessage, poisonMessageQueue: "error"); senderConfig.UseTransport <MsmqTransport>(); var sender = await RawEndpoint.Start(senderConfig) .ConfigureAwait(false); #endregion #region Sending var body = Serialize(); var headers = new Dictionary <string, string> { ["SomeHeader"] = "SomeValue" }; var request = new OutgoingMessage( messageId: Guid.NewGuid().ToString(), headers: headers, body: body); var operation = new TransportOperation( request, new UnicastAddressTag("Receiver")); await sender.SendRaw( outgoingMessages : new TransportOperations(operation), transaction : new TransportTransaction(), context : new ContextBag()) .ConfigureAwait(false); #endregion }
public async Task StartAsync(CancellationToken cancellationToken) { var nameShortener = new RuleNameShortener(); var endpointConfigurationRaw = RawEndpointConfiguration.Create(_attribute.Endpoint, OnMessage, _poisonMessageQueue); if (_nServiceBusOptions.EndpointConfiguration != null) { endpointConfigurationRaw = _nServiceBusOptions.EndpointConfiguration.Invoke(endpointConfigurationRaw); } else { var tokenProvider = TokenProvider.CreateManagedIdentityTokenProvider(); endpointConfigurationRaw.UseTransport <AzureServiceBusTransport>() .RuleNameShortener(nameShortener.Shorten) .CustomTokenProvider(tokenProvider) .ConnectionString(_attribute.Connection) .Transactions(TransportTransactionMode.ReceiveOnly); } if (!string.IsNullOrEmpty(EnvironmentVariables.NServiceBusLicense)) { endpointConfigurationRaw.UseLicense(EnvironmentVariables.NServiceBusLicense); } endpointConfigurationRaw.DefaultErrorHandlingPolicy(_poisonMessageQueue, ImmediateRetryCount); endpointConfigurationRaw.AutoCreateQueue(); _endpoint = await RawEndpoint.Start(endpointConfigurationRaw).ConfigureAwait(false); if (_nServiceBusOptions.OnStarted != null) { _nServiceBusOptions.OnStarted.Invoke(_endpoint); } await _endpoint.SubscriptionManager.Subscribe(_parameter.ParameterType, new ContextBag()); }
public static async Task Main(string[] args) { var nhConfig = new Configuration(); nhConfig.SetProperty(Environment.ConnectionProvider, "NHibernate.Connection.DriverConnectionProvider"); nhConfig.SetProperty(Environment.ConnectionDriver, "NHibernate.Driver.Sql2008ClientDriver"); nhConfig.SetProperty(Environment.Dialect, "NHibernate.Dialect.MsSql2008Dialect"); nhConfig.SetProperty(Environment.ConnectionString, System.Environment.GetEnvironmentVariable("SQLServerConnectionString")); var mapper = new ModelMapper(); mapper.AddMapping <TimeoutEntityMap>(); var mappings = mapper.CompileMappingForAllExplicitlyAddedEntities(); nhConfig.AddMapping(mappings); var sessionFactory = nhConfig.BuildSessionFactory(); var senderConfig = RawEndpointConfiguration.CreateSendOnly("DUMMY"); var transport = senderConfig.UseTransport <SqsTransport>(); transport.UnrestrictedDurationDelayedDelivery(); var sender = await RawEndpoint.Start(senderConfig) .ConfigureAwait(false); var ignoreMachineName = true; // Must be true for Sqs var now = DateTime.UtcNow; using (var session = sessionFactory.OpenStatelessSession()) { var timeoutEntities = await session.Query <TimeoutEntity>().Take(100).ToListAsync(); var transportOperations = new List <TransportOperation>(); foreach (var timeout in timeoutEntities) { await Console.Out.WriteLineAsync($"Id:{timeout.Id} Time:{timeout.Time:s} Destination:{timeout.Destination} {timeout.Endpoint}").ConfigureAwait(false); var body = timeout.State; var headers = ConvertStringToDictionary(timeout.Headers); var timestamp = timeout.Time; var destination = timeout.Destination; var id = headers["NServiceBus.MessageId"]; if (ignoreMachineName) { var at = destination.LastIndexOf("@", StringComparison.InvariantCulture); if (at != -1) { destination = destination.Substring(0, at); } } var age = now - timestamp; var request = new OutgoingMessage( messageId: timeout.Id.ToString(), headers: headers, body: body ); var operation = new TransportOperation( request, new UnicastAddressTag(destination) , DispatchConsistency.Default, new List <DeliveryConstraint> { new DoNotDeliverBefore(timestamp) }); if (age.Ticks > 0) { await Console.Out.WriteLineAsync($"Warning: Message {id} was scheduled for {timestamp} which passed {age} ago.") .ConfigureAwait(false); } transportOperations.Add(operation); } await sender.Dispatch( outgoingMessages : new TransportOperations(transportOperations.ToArray()), transaction : new TransportTransaction(), context : new ContextBag() ) .ConfigureAwait(false); } }
private static async Task Main(string[] args) { var maxConcurrency = 10; var channel = Channel.CreateBounded <MessageContext>(new BoundedChannelOptions(maxConcurrency) { SingleReader = true, SingleWriter = false, AllowSynchronousContinuations = false, FullMode = BoundedChannelFullMode.Wait }); var senderConfig = RawEndpointConfiguration.Create("Sender", (ctx, disp) => OnMessage(ctx, disp, channel), "error"); senderConfig.AutoCreateQueue(); var transport = senderConfig.UseTransport <RabbitMQTransport>(); transport.UseConventionalRoutingTopology(); transport.ConnectionString("host=localhost"); senderConfig.LimitMessageProcessingConcurrencyTo(maxConcurrency); async Task ReadChannel(Channel <MessageContext> channel) { var contexts = new List <MessageContext>(maxConcurrency); await Console.Error.WriteLineAsync("Start reading..."); while (await channel.Reader.WaitToReadAsync().ConfigureAwait(false)) { try { await Console.Error.WriteLineAsync("Start TryRead..."); while (channel.Reader.TryRead(out var context)) { contexts.Add(context); } await Console.Error.WriteLineAsync($"Got pushed {contexts.Count} contexts."); foreach (var context in contexts) { await Console.Error.WriteAsync("."); context.Extensions.Get <TaskCompletionSource <bool> >().TrySetResult(true); } } finally { contexts.Clear(); } await Console.Error.WriteLineAsync("Done TryRead..."); } await Console.Error.WriteLineAsync("Done reading..."); } var readerTask = Task.Run(() => ReadChannel(channel)); var sender = await RawEndpoint.Start(senderConfig).ConfigureAwait(false); var cts = new CancellationTokenSource(); async Task ProduceMessages(IReceivingRawEndpoint sender, CancellationToken cancellationToken) { while (!cancellationToken.IsCancellationRequested) { var transportOperations = new TransportOperation[15]; for (var i = 0; i < 15; i++) { var headers = new Dictionary <string, string> { ["SomeHeader"] = "SomeValue" }; var request = new OutgoingMessage(Guid.NewGuid().ToString(), headers, Array.Empty <byte>()); transportOperations[i] = new TransportOperation(request, new UnicastAddressTag("Sender")); } await sender.Dispatch( new TransportOperations(transportOperations), //Can have multiple sends in one batch new TransportTransaction(), new ContextBag()) .ConfigureAwait(false); try { await Task.Delay(100, cts.Token); } catch (OperationCanceledException) { // ignored } } await Console.Error.WriteLineAsync("Stopped sending"); } var senderTask = Task.Run(() => ProduceMessages(sender, cts.Token), CancellationToken.None); await Console.Error.WriteLineAsync("Press any key to stop"); await Console.In.ReadLineAsync(); cts.CancelAfter(TimeSpan.FromSeconds(15)); await sender.StopReceiving(); channel.Writer.Complete(); await readerTask; await senderTask; }
public Task Start() { return(endpoint.Start()); }
public async Task Run(CancellationToken token) { var config = rawEndpointFactory.CreateSendOnlyRawEndpointConfiguration("ImportFailedErrors"); var endpoint = await RawEndpoint.Start(config).ConfigureAwait(false); await errorIngestor.Initialize(endpoint).ConfigureAwait(false); try { var succeeded = 0; var failed = 0; using (var session = store.OpenAsyncSession()) { var query = session.Query <FailedErrorImport, FailedErrorImportIndex>(); using (var ie = await session.Advanced.StreamAsync(query, token) .ConfigureAwait(false)) { while (!token.IsCancellationRequested && await ie.MoveNextAsync().ConfigureAwait(false)) { FailedTransportMessage dto = ((dynamic)ie.Current.Document).Message; try { var messageContext = new MessageContext(dto.Id, dto.Headers, dto.Body, EmptyTransaction, EmptyTokenSource, EmptyContextBag); await errorIngestor.Ingest(messageContext).ConfigureAwait(false); await store.AsyncDatabaseCommands.DeleteAsync(ie.Current.Key, null, token) .ConfigureAwait(false); succeeded++; if (Logger.IsDebugEnabled) { Logger.Debug($"Successfully re-imported failed error message {dto.Id}."); } } catch (OperationCanceledException) { // no-op } catch (Exception e) { Logger.Error($"Error while attempting to re-import failed error message {dto.Id}.", e); failed++; } } } } Logger.Info($"Done re-importing failed errors. Successfully re-imported {succeeded} messages. Failed re-importing {failed} messages."); if (failed > 0) { Logger.Warn($"{failed} messages could not be re-imported. This could indicate a problem with the data. Contact Particular support if you need help with recovering the messages."); } } finally { await endpoint.Stop().ConfigureAwait(false); } }