protected static Task <TResult> SendAsync <TQueueProcessor, TResult>(TMessageParam messageParams, string subscription, Func <TResult> onSent, Func <string, TResult> onFailure) where TQueueProcessor : QueueProcessor <TMessageParam> { return(Web.Configuration.Settings.GetString( Security.SessionServer.Configuration.AppSettings.ServiceBusConnectionString, async serviceBusConnectionString => { var message = new Microsoft.Azure.ServiceBus.Message(); EncodeMessageParams(message.UserProperties, messageParams); message.UserProperties[MESSAGE_PROPERTY_KEY_MESSAGE_NAME] = subscription; var sendClient = new Microsoft.Azure.ServiceBus.QueueClient(serviceBusConnectionString, subscription); try { await sendClient.SendAsync(message); return onSent(); } catch (Exception ex) { return onFailure(ex.Message); } finally { await sendClient.CloseAsync(); } }, onFailure.AsAsyncFunc())); }
public static async Task <Microsoft.Azure.ServiceBus.Message> ReceiveAsync(this Microsoft.Azure.ServiceBus.QueueClient sbClient, TimeSpan?timeout) { var receiver = (Microsoft.Azure.ServiceBus.Core.MessageReceiver)InnerReceiverProperty.GetValue(sbClient); var msg = timeout.HasValue ? await receiver.ReceiveAsync(timeout.Value) : await receiver.ReceiveAsync(); return(msg); }
public ServiceBusSender(IConfigureServiceBus configure) { _connectionStringServiceBus = configure.ConnectionStringServiceBus; _connectionStringBlobStorage = configure.ConnectionStringBlobStorage; _queueName = configure.QueueName; _containerName = configure.ContainerName; _queueClient = new Microsoft.Azure.ServiceBus.QueueClient(_connectionStringServiceBus, _queueName); _container = new BlobContainerClient(_connectionStringBlobStorage, _containerName); _container.CreateIfNotExists(); }
public AzureServiceBusMqServerAppHostTests() { #if !NETCORE_SUPPORT NamespaceManager nm = NamespaceManager.CreateFromConnectionString(ConnectionString); Parallel.ForEach(nm.GetQueues(), qd => { var sbClient = QueueClient.CreateFromConnectionString(ConnectionString, qd.Path, ReceiveMode.ReceiveAndDelete); BrokeredMessage msg = null; while ((msg = sbClient.Receive(new TimeSpan(0, 0, 1))) != null) { } }); #endif }
public async Task <IActionResult> SendEmail([FromServices] IOptions <ServiceBusOptions> options, SendEmailRequest sendEmailRequest) { var email = Newtonsoft.Json.JsonConvert.SerializeObject(sendEmailRequest); var messagecontent = System.Text.Encoding.UTF8.GetBytes(email); var qc = new Microsoft.Azure.ServiceBus.QueueClient(options.Value.ConnectionString, "email-input"); await qc.SendAsync(new Microsoft.Azure.ServiceBus.Message(messagecontent)); // var random = new Random(); // Thread.Sleep(random.Next(3000, 8000)); // if(random.Next(0, 1) > 0) // return StatusCode(InternalServerErrorHttpStatusCode); return(RedirectToAction(nameof(Index))); }
protected QueueProcessor(string subscription) { subscription = subscription.ToLower(); subscriptions = subscriptions.Append(subscription).ToArray(); var xexecutionThread = Web.Configuration.Settings.GetString( EastFive.Security.SessionServer.Configuration.AppSettings.ServiceBusConnectionString, serviceBusConnectionString => { var receiveClient = new Microsoft.Azure.ServiceBus.QueueClient(serviceBusConnectionString, subscription); // TODO: Create the topic if it does not exist already but swallow the errors if manage privilige is not available Func <Microsoft.Azure.ServiceBus.Message, CancellationToken, Task> processMessagesAsync = async(message, cancellationToken) => { try { processing = true; await ProcessAsync(message, receiveClient); } catch (Exception ex) { ex.Message.GetType(); } finally { processing = false; } }; var messageHandlerOptions = new Microsoft.Azure.ServiceBus.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 = 1, // 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, MaxAutoRenewDuration = TimeSpan.FromHours(1), }; // Register the function that processes messages. receiveClient.RegisterMessageHandler(processMessagesAsync, messageHandlerOptions); return(string.Empty); }, (why) => why); }
private async Task ProcessAsync(Microsoft.Azure.ServiceBus.Message message, Microsoft.Azure.ServiceBus.QueueClient client) //private async Task Execute(BrokeredMessage receivedMessage) { try { // Process the message var messageParams = ParseMessageParams(message.UserProperties); var messageAction = await ProcessMessageAsync <MessageProcessStatus>(messageParams, async() => { //message.Complete(); await client.CompleteAsync(message.SystemProperties.LockToken); return(MessageProcessStatus.Complete); }, async() => { // TODO: Update resent count and send error if it gets too large // Let message get resent await client.ScheduleMessageAsync(message, DateTimeOffset.UtcNow + TimeSpan.FromSeconds(10)); return(MessageProcessStatus.ReprocessImmediately); }, async (whyReturned) => { await client.DeadLetterAsync(message.SystemProperties.LockToken, whyReturned); return(MessageProcessStatus.Broken); }); } catch (Exception ex) { //var telemetryData = (new System.Collections.Generic.Dictionary<string, string> // { // { "receivedMessage.MessageId", receivedMessage.MessageId }, // { "receivedMessage.SessionId", receivedMessage.SessionId }, // { "receivedMessage.ContentType", receivedMessage.ContentType }, // { "receivedMessage.SequenceNumber", receivedMessage.SequenceNumber.ToString() }, // { "exception.Message", ex.Message }, // { "exception.StackTrace", ex.StackTrace }, // }) //.Concat(receivedMessage.Properties // .Select(prop => $"receivedMessage.Properties[{prop.Key}]".PairWithValue( // null == prop.Value ? string.Empty : prop.Value.ToString()))) //.ToDictionary(); //telemetry.TrackException(ex, telemetryData); await client.DeadLetterAsync(message.SystemProperties.LockToken, ex.Message); } }