public async Task When_Listener_Is_Opened_Register_MessageHandler()
{
await _sut.OpenAsync(CancellationToken.None);
A.CallTo(() =>
_receiverClient.RegisterMessageHandler(
A <Func <Message, CancellationToken, Task> > ._,
A <MessageHandlerOptions> ._))
.MustHaveHappenedOnceExactly();
}
/// <summary>
/// Receives from queue.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="targetModel">The target model.</param>
/// <param name="handler">The handler.</param>
/// <returns></returns>
public bool ReceiveFromQueue <T>(T targetModel, Func <T, Task> handler)
{
try
{
ServiceBusDetails serviceBusDetails = GetServiceBusDetailsFromT(targetModel.GetType());
if (!string.IsNullOrEmpty(serviceBusDetails.Connection))
{
receiverClient = new AzureQueueReceiver(serviceBusDetails.Connection, serviceBusDetails.QueueName);
MessageHandlerOptions messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 50,
AutoComplete = true
};
//subscriptionClient.RegisterMessageHandler(handler, messageHandlerOptions);
receiverClient.RegisterMessageHandler(async(msg, token) =>
{
// Get message
string message = Encoding.UTF8.GetString(msg.Body).ToBase64Decode();
dynamic obj = JsonConvert.DeserializeObject(message);
dynamic retrunModel = JsonConvert.DeserializeObject <T>(JsonConvert.SerializeObject(obj.originalvalue));
handler(retrunModel);
}, messageHandlerOptions);
return(true);
}
return(false);
}
catch (Exception)
{
return(false);
}
}
public Task SubscribeAsync(CancellationToken cancelToken)
{
if (cancelToken == null)
{
throw new ArgumentNullException(nameof(cancelToken));
}
if (IsClosed)
{
throw new InvalidOperationException("Service bus connection has already been closed.");
}
if ((receiverClient == null) && (cancelToken.IsCancellationRequested == false))
{
receiverClient = CreateReceiverClient();
var messageHandlerOptions = new MessageHandlerOptions(HandleMessagingExceptionAsync)
{
AutoComplete = false
};
cancelToken.Register(async() => await receiverClient.CloseAsync().ConfigureAwait(false));
receiverClient.RegisterMessageHandler(HandleMessageAsync, messageHandlerOptions);
}
return(Task.CompletedTask);
}
public Task StartMessagePumpAsync(
Func <IReadOnlyCollection <QueueMessage>, CancellationToken, Task> onMessageAsync,
int maxBatchSize = 1,
CancellationToken cancellationToken = default)
{
if (onMessageAsync == null)
{
throw new ArgumentNullException(nameof(onMessageAsync));
}
_receiverClient.PrefetchCount = maxBatchSize;
_receiverClient.RegisterMessageHandler(
async(message, token) =>
{
QueueMessage qm = Converter.ToQueueMessage(message);
if (!_autoComplete)
{
_messageIdToBrokeredMessage[qm.Id] = message;
}
await onMessageAsync(new[] { qm }, token).ConfigureAwait(false);
},
_messageHandlerOptions);
return(Task.FromResult(true));
}
public ChannelReceiver(IReceiverClient receiverClient,
Func <TMessage, Task> messageHandler,
ILogger logger)
{
receiverClient.RegisterMessageHandler(async(v, token) =>
{
try
{
var messageObject = JsonConvert.DeserializeObject <TMessage>(Encoding.UTF8.GetString(v.Body));
await messageHandler(messageObject).ConfigureAwait(false);
}
catch (Exception ex)
{
logger.Exception(ex);
}
}, new MessageHandlerOptions(v =>
{
logger.Exception(v.Exception);
return(Task.CompletedTask);
})
{
AutoComplete = true,
MaxConcurrentCalls = 1
});
}
public async Task Start()
{
var serviceBusConnectionString = _configuration.GetConnectionString("AzureServiceBus");
_serviceBusConfig = _configuration.GetSection(nameof(ServiceBusConfig)).Get <ServiceBusConfig>();
var busConfig = _configuration.GetSection(nameof(BusConfig)).Get <BusConfig>();
if (busConfig != null)
{
_logger.LogWarning($"{busConfig.BusType} with ConnectionString {serviceBusConnectionString.ReplaceWithStars(20)} will delay start for {busConfig.BusDelayStartInSec} ");
await Task.Delay(busConfig.BusDelayStartInSec * 1000);
_logger.LogWarning($"{busConfig.BusType} connecting...");
}
_approvedAdoProjcetMessageReceiverClient = new SubscriptionClient(serviceBusConnectionString, _serviceBusConfig.ApprovedAdoProjectsTopic, _serviceBusConfig.ApprovedAdoProjectsSub);
_rejectedAdoProjcetMessageReceiverClient = new SubscriptionClient(serviceBusConnectionString, _serviceBusConfig.RejectedAdoProjectsTopic, _serviceBusConfig.RejectedAdoProjectsSub);
//queueReceiverClient = new QueueClient(serviceBusConnectionString, _serviceBusConfig.QueueNameTest);
var messageHandlerOptions = new MessageHandlerOptions(OnServiceBusException)
{
MaxConcurrentCalls = 5, AutoComplete = false
};
_approvedAdoProjcetMessageReceiverClient?.RegisterMessageHandler(OnApprovedReceived, messageHandlerOptions);
_rejectedAdoProjcetMessageReceiverClient?.RegisterMessageHandler(OnRejectedReceived, messageHandlerOptions);
//queueReceiverClient?.RegisterMessageHandler(ExecuteQueueMessageProcessing, messageHandlerOptions);
}
private void RegisterForMessages()
{
var options = new MessageHandlerOptions(MessageException);
options.AutoComplete = false;
options.MaxConcurrentCalls = int.MaxValue;
receiver.RegisterMessageHandler(MessageHandler, options);
}
public void Start()
{
var messageHandlerOptions = new MessageHandlerOptions(OnServiceBusException)
{
MaxConcurrentCalls = 4
};
checkoutMessageReceiverClient.RegisterMessageHandler(OnCheckoutMessageReceived, messageHandlerOptions);
}
public void Start()
{
var messageHandlerOptions = new MessageHandlerOptions(OnServiceBusException)
{
MaxConcurrentCalls = 4
};
productCreatedMessageReceiverClient.RegisterMessageHandler(OnProductCreatedMessageReceived, messageHandlerOptions);
}
public void StartListener(Action <Message> handler)
{
_receiverClient.RegisterMessageHandler(
(message, token) =>
{
handler(message);
return(Task.CompletedTask);
},
(eventArgs) => Task.CompletedTask);
}
public RequestReplySender(ISenderClient sender, IReceiverClient receiver)
{
_sender = sender;
_receiver = receiver;
_receiver.RegisterMessageHandler(OnMessageReceived,
new MessageHandlerOptions(ExceptionReceivedHandler)
{
AutoComplete = false
});
}
public void PurgeServiceBusMessagesAsync(IReceiverClient receiverClient, ITestOutputHelper output)
{
receiverClient.RegisterMessageHandler(async(Microsoft.Azure.ServiceBus.Message message, CancellationToken token) =>
{
// purge message
await receiverClient.CompleteAsync(message.SystemProperties.LockToken);
}, new MessageHandlerOptions(async args => output.WriteLine(args.Exception.ToString()))
{
MaxConcurrentCalls = 1,
AutoComplete = false
});
}
public async Task RegisterSubscriber()
{
if (!_configuration.GetValue <bool>("CodeFirstServiceBus", false))
{
await AddFilters();
}
_receiverClient.RegisterMessageHandler(ProcessMessagesAsync, new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
});
}
public void StartListening()
{
activeClient = CreateListener();
activeClient.RegisterMessageHandler((message, handler) =>
{
OnMessageReceived?.Invoke(this, new OnMessageReceivedEventArgs(message));
return(activeClient.CompleteAsync(message.SystemProperties.LockToken));
}, new MessageHandlerOptions(x => Task.CompletedTask));
Console.WriteLine("Started Listening for " + this.GetType().Name);
}
public Consumer(IReceiverClient receiverClient, int maxConcurrentCalls = 5)
{
_receiverClient = receiverClient;
_subject = new Subject <IMessage <T> >();
MessageSource = _subject.AsObservable();
var messageHandlerOptions = new MessageHandlerOptions(exceptionHandlerAsync)
{
MaxConcurrentCalls = maxConcurrentCalls,
AutoComplete = false
};
_receiverClient.RegisterMessageHandler(messageHandlerAsync, messageHandlerOptions);
}
public void Register()
{
// Configure the MessageHandler Options in terms of exception handling, number of concurrent messages to deliver etc.
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
// Maximum number of Concurrent calls to the callback `ProcessMessagesAsync`, set to 1 for simplicity.
// Set it according to how many messages the application wants to process in parallel.
MaxConcurrentCalls = 10,
// Indicates whether MessagePump should automatically complete the messages after returning from User Callback.
// False below indicates the Complete will be handled by the User Callback as in `ProcessMessagesAsync` below.
AutoComplete = false,
};
// Register the function that will process messages
_client.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
protected WorkerBase(
IReceiverClient receiverClient,
Scoped <IWorkflowLaunchpad> workflowLaunchpad,
IOptions <AzureServiceBusOptions> options,
Func <IReceiverClient, Task> disposeReceiverAction,
ILogger logger)
{
ReceiverClient = receiverClient;
_workflowLaunchpad = workflowLaunchpad;
_disposeReceiverAction = disposeReceiverAction;
_logger = logger;
ReceiverClient.RegisterMessageHandler(OnMessageReceived, new MessageHandlerOptions(ExceptionReceivedHandler)
{
AutoComplete = false,
MaxConcurrentCalls = options.Value.MaxConcurrentCalls
});
}
public async Task RegisterSubscriber(ChannelType channelType)
{
if (_configuration.IsCodeFirstServiceBus())
{
InitializeClients(channelType);
}
else
{
await AddFilters();
}
_receiverClient.RegisterMessageHandler(
ProcessMessagesAsync,
new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
});
}
/// <summary>
/// Receive messages
/// </summary>
/// <param name="exceptionHandler">The exception handler for exposing any exceptions that happen during receive</param>
/// <param name="maxConcurrentCalls">Gets or sets the maximum number of concurrent calls to the callback the message pump should initiate. Default is 1</param>
/// <returns>An observable of type T</returns>
public IObservable <T> Receive(Func <ExceptionReceivedEventArgs, Task> exceptionHandler, int maxConcurrentCalls = 1)
{
var ob = Observable.Create <T>(o =>
{
_client.RegisterMessageHandler(async(message, token) =>
{
var data = JsonConvert.DeserializeObject <T>(Encoding.UTF8.GetString(message.Body));
o.OnNext(data);
await _client.CompleteAsync(message.SystemProperties.LockToken).ConfigureAwait(false);
}, new MessageHandlerOptions(exceptionHandler)
{
AutoComplete = false, MaxConcurrentCalls = maxConcurrentCalls
});
return(Disposable.Empty);
});
return(ob);
}
public async Task Start()
{
var serviceBusConnectionString = _configuration.GetConnectionString("AzureServiceBus");
_serviceBusConfig = _configuration.GetSection(nameof(ServiceBusConfig)).Get <ServiceBusConfig>();
var busConfig = _configuration.GetSection(nameof(BusConfig)).Get <BusConfig>();
if (busConfig != null)
{
_logger.LogWarning($"{busConfig.BusType} with ConnectionString {serviceBusConnectionString.ReplaceWithStars(20)} will delay start for {busConfig.BusDelayStartInSec} ");
await Task.Delay(busConfig.BusDelayStartInSec * 1000);
_logger.LogWarning($"{busConfig.BusType} connecting...");
}
_wmOperationRequestMessageReceiverClient = new SubscriptionClient(serviceBusConnectionString, _serviceBusConfig.VmOperationRequesTopic, _serviceBusConfig.VmOperationRequesSub);
var messageHandlerOptions = new MessageHandlerOptions(OnServiceBusException)
{
MaxConcurrentCalls = 5, AutoComplete = false
};
_wmOperationRequestMessageReceiverClient?.RegisterMessageHandler(OnVmOperationReceived, messageHandlerOptions);
}
private static async Task <T> GetMessageBodyAsync <T>(IReceiverClient client)
{
string body = null;
client.RegisterMessageHandler(async(msg, token) =>
{
Message message = msg;
if (message != null)
{
body = Encoding.UTF8.GetString(message.Body);
if (body.Contains("spoiled", StringComparison.OrdinalIgnoreCase))
{
await client.DeadLetterAsync(msg.SystemProperties.LockToken);
}
else
{
await client.CompleteAsync(msg.SystemProperties.LockToken);
}
}
}, new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
});
await client.UnregisterMessageHandlerAsync(TimeSpan.FromMilliseconds(2000));
await client.CloseAsync();
if (body != null)
{
return(JsonSerializer.Deserialize <T>(body));
}
return(default);
public BaseConsumer(ServiceBusMessageBus messageBus, AbstractConsumerSettings consumerSettings, IReceiverClient client, IMessageProcessor <Message> messageProcessor, ILog log)
{
_log = log;
MessageBus = messageBus;
ConsumerSettings = consumerSettings;
Client = client;
MessageProcessor = messageProcessor;
// Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
// Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity.
// Set it according to how many messages the application wants to process in parallel.
MaxConcurrentCalls = consumerSettings.Instances,
// Indicates whether the message pump should automatically complete the messages after returning from user callback.
// False below indicates the complete operation is handled by the user callback as in ProcessMessagesAsync().
AutoComplete = false
};
// Register the function that processes messages.
Client.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
}
internal void RegisterMessageHandler(Func <Message, CancellationToken, Task> handler, MessageHandlerOptions messageHandlerOptions)
{
_receiverClient.RegisterMessageHandler(handler, messageHandlerOptions);
}
static string Read(IReceiverClient client, bool peek, int numMessages, int time)
{
System.Timers.Timer timer = new System.Timers.Timer();
System.Timers.Timer logTimer = new System.Timers.Timer()
{
Interval = 2000, AutoReset = true
};
client.PrefetchCount = numMessages;
var messages = new StringBuilder();
int n = 0;
bool isTimeUp = false;
timer.Elapsed += (object source, System.Timers.ElapsedEventArgs e) => { isTimeUp = true; };
logTimer.Elapsed += (object source, System.Timers.ElapsedEventArgs e) => {
if (Verbose)
{
Console.WriteLine("Waiting for messages...");
}
};
if (time >= 0)
{
timer.Interval = time * 1000;
timer.Start();
}
logTimer.Start();
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
try
{
client.RegisterMessageHandler(async(Message message, CancellationToken token) =>
{
if (Verbose)
{
Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber}");
}
Console.WriteLine(Encoding.UTF8.GetString(message.Body));
messages.Append(Encoding.UTF8.GetString(message.Body));
if (!peek)
{
await client.CompleteAsync(message.SystemProperties.LockToken);
}
n++;
}, messageHandlerOptions);
while (n < numMessages && !isTimeUp)
{
}
}
catch (Exception e)
{
Console.WriteLine($"Ooops, trying to read messages failed: {e}");
}
finally
{
client.CloseAsync();
timer.Stop();
logTimer.Stop();
}
return(messages.ToString());
}