private static void ReceiveMessage() { TokenProvider tokenProvider = _namespaceManager.Settings.TokenProvider;; if (_namespaceManager.TopicExists("DataCollectionTopic")) { MessagingFactory factory = MessagingFactory.Create(_namespaceManager.Address, tokenProvider); //Same as Queue ReceiveMode.PeekLock is default MessageReceiver receiver = factory.CreateMessageReceiver("DataCollectionTopic/subscriptions/Inventory"); MessageReceiver receiver1 = factory.CreateMessageReceiver("DataCollectionTopic/subscriptions/Dashboard"); BrokeredMessage receivedMessage = null; try { Console.WriteLine($"From Inventory"); while ((receivedMessage = receiver.Receive()) != null) { ProcessMessage(receivedMessage); receivedMessage.Complete(); } Console.WriteLine($"From Dashboard"); while ((receivedMessage = receiver1.Receive()) != null) { ProcessMessage(receivedMessage); receivedMessage.Complete(); } factory.Close(); _namespaceManager.DeleteSubscription("DataCollectionTopic", "Inventory"); _namespaceManager.DeleteSubscription("DataCollectionTopic", "Dashboard"); _namespaceManager.DeleteTopic("DataCollectionTopic"); } catch (Exception ex) { Console.WriteLine(ex.ToString()); receivedMessage.Abandon(); } #region With Collection //IEnumerable<BrokeredMessage> receivedMessageList = receiver.ReceiveBatch(2); //try //{ // foreach (var item in receivedMessageList) // { // ProcessMessage(item); // item.Complete(); // } // factory.Close(); // _namespaceManager.DeleteSubscription("DataCollectionTopic", "Inventory"); // //_namespaceManager.DeleteSubscription("DataCollectionTopic", "Dashboard"); // //_namespaceManager.DeleteTopic("DataCollectionTopic"); //} //catch (Exception ex) //{ // Console.WriteLine(ex.ToString()); //} #endregion } }
public IListener CreateListener(string path, bool allowRetries) { var receiver = MessagingFactory.CreateMessageReceiver(path, allowRetries ? ReceiveMode.PeekLock : ReceiveMode.ReceiveAndDelete); return(new PacketListener(receiver, this)); }
public void Scenario10_QueueRequestResponse(string queue, string replyTo) { WorkerThread receiverThread = new WorkerThread(this.Scenario11_QueueReceiver); receiverThread.Start(queue); ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(this.ConnectionString); builder.TransportType = TransportType.Amqp; MessagingFactory factory = MessagingFactory.CreateFromConnectionString(this.ConnectionString); MessageSender sender = factory.CreateMessageSender(queue); MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes("Request")); BrokeredMessage message = new BrokeredMessage(stream); message.MessageId = Guid.NewGuid().ToString(); message.ReplyTo = replyTo; message.Properties["time"] = DateTime.UtcNow; sender.Send(message); MessageReceiver receiver = factory.CreateMessageReceiver(replyTo); BrokeredMessage response = receiver.Receive(); response.Complete(); sender.Close(); receiver.Close(); factory.Close(); }
static void ReceiveMessage() { TokenProvider tokenProvider = _namespaceManager.Settings.TokenProvider; if (_namespaceManager.TopicExists("DataCollectionTopic")) { MessagingFactory factory = MessagingFactory.Create(_namespaceManager.Address, tokenProvider); //MessageReceiver receiver = factory.CreateMessageReceiver("DataCollectionTopic/subscriptions/Inventory"); MessageReceiver receiver = factory.CreateMessageReceiver("DataCollectionTopic/subscriptions/Dashboard"); BrokeredMessage receivedMessage = null; try { while ((receivedMessage = receiver.Receive()) != null) { ProcessMessage(receivedMessage); receivedMessage.Complete(); } factory.Close(); _namespaceManager.DeleteSubscription("DataCollectionTopic", "Inventory"); // _namespaceManager.DeleteTopic("DataCollectionTopic"); } catch (Exception ex) { Console.WriteLine(ex.ToString()); receivedMessage.Abandon(); } } }
static async Task AsyncMain() { MessagingFactory fact = MessagingFactory.CreateFromConnectionString(ConfigurationManager.AppSettings["ConnectionString"]); var sender = fact.CreateMessageSender("destinationQueue", "queue2"); var receiver = fact.CreateMessageReceiver("queue2", ReceiveMode.PeekLock); BrokeredMessage msg; BrokeredMessage recMsg; var i = 0; while (i < 5000) { recMsg = await receiver.ReceiveAsync(); msg = new BrokeredMessage(); if (recMsg != null) { using (var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { msg.ScheduledEnqueueTimeUtc = DateTime.UtcNow.AddMinutes(6); await recMsg.CompleteAsync(); await sender.SendAsync(msg); scope.Complete(); i++; } } } }
public void HandleRegenerateSite() { long n = 0; allMessages = factory.CreateMessageReceiver(regenSiteTopic + "/subscriptions/AllMessages", ReceiveMode.PeekLock); while (_running) { BrokeredMessage message = allMessages.Receive(); if (message != null) { // let the message go back to the pool Int64.TryParse(message.Properties["MessageNumber"].ToString(), out n); message.Abandon(); try { if (n > maxMessage) { maxMessage = n; Console.WriteLine("\r\nAccepted message to regenerate site: {0} ", n); RebuildWebsite(); } else { // Console.WriteLine("\r\nSkipping: {0} ",n); } } catch (Exception) { } Thread.Sleep(8000); // wait 5 seconds to give other consumers a chance on this message. } } }
static async Task Deadletter() { try { string ServiceBusConnectionString = "Endpoint=sb://pricechange.servicebus.windows.net/;SharedAccessKeyName=cartitempricechange;SharedAccessKey=zOK+zZifCv4xX4f0af4Bctrg6tXeLKvwD9vhBT9YlZ8="; string TopicName = "pricechange-topic"; string SubscriptionName = "pricechange-topic-subscription"; MessagingFactory factory = MessagingFactory.CreateFromConnectionString(ServiceBusConnectionString); string path = Microsoft.ServiceBus.Messaging.SubscriptionClient.FormatDeadLetterPath(TopicName, SubscriptionName); Microsoft.ServiceBus.Messaging.MessageReceiver deadletterReceiver = factory.CreateMessageReceiver(path); BrokeredMessage msg = deadletterReceiver.Receive(); if (msg != null) { var messageBody = new StreamReader(msg.GetBody <Stream>(), Encoding.UTF8).ReadToEnd(); var receivedMessage = JsonConvert.DeserializeObject <ServiceBusMessage>(messageBody); Console.WriteLine($"Received message: UserInfo:{receivedMessage.Id}"); Console.ReadKey(); msg.Complete(); } } catch (Exception ex) { throw ex; } }
public void Start() { while (Enabled) { _factory = MessagingFactory.CreateFromConnectionString(_connectionString); var messageReceiver = _factory.CreateMessageReceiver(_path, ReceiveMode.PeekLock); var brokeredMessage = messageReceiver.Receive(); if (brokeredMessage == null) { continue; } var messageType = brokeredMessage.Label; var replyTo = brokeredMessage.ReplyTo; var replySessionId = brokeredMessage.ReplyToSessionId; var messageHandler = MessageHandlerFactory.GetHandler(string.Empty); messageHandler.Forwarder = _forwarder; Console.WriteLine("Received message {0} on {1} and forwarded to {2}", messageType, _path, _forwarder); var response = messageHandler.HandleRequestResponse(brokeredMessage); if (!string.IsNullOrEmpty(replyTo)) { var responseMessageClient = new ResponseMessageClient(_connectionString, replyTo, replySessionId); Console.WriteLine("Send message response"); responseMessageClient.SendResponse((MemoryStream)response, messageType); } messageReceiver.Complete(brokeredMessage.LockToken); } }
protected static void AzureMessageConsumer(MessagingFactory f) { //use the already created messaging factory to create a msg receiver MessageReceiver testQueueReceiver = f.CreateMessageReceiver("colors"); while (true) { using (BrokeredMessage retrievedMessage = testQueueReceiver.Receive()) { try { string msgResult = retrievedMessage.GetBody<string>(); //call SP to insert the data into the proper table InsertSQL(msgResult); Console.WriteLine("Message received: " + msgResult); retrievedMessage.Complete(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); retrievedMessage.Abandon(); } } } }
private async void ProcessQueuedMessages(SubscriptionClient client) { try { MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connectionString); MessageReceiver messageReceiver = factory.CreateMessageReceiver(SubscriptionClient.FormatDeadLetterPath(topicPath, subscriptionName)); IEnumerable <BrokeredMessage> messageSet = messageReceiver.ReceiveBatch(10000); Debug.WriteLine("**** Received " + messageSet.Count() + " messages *****"); foreach (BrokeredMessage message in messageSet) { try { await processMessage(message); Debug.WriteLine("**** ProcessQueuedMessages.processMessage completed ****"); } catch (Exception e) { Debug.WriteLine("**** Error ProcessQueuedMessages.processMessage " + e.ToString() + " ****"); } } } catch { Debug.WriteLine("**** Error ProcessQueuedMessages ****"); } }
private void Listen(ReceiveMode receiveMode) { var mr = _messagingFactory.CreateMessageReceiver(_subscription.FullPath, receiveMode); while (_isListening) { BrokeredMessage message = null; try { message = mr.Receive(); } catch (TimeoutException) { ListeningTimedOut?.Invoke(); continue; } catch (OperationCanceledException) //When Cancel() is called on client or factory { return; } catch (Exception ex) { ExceptionOccured?.Invoke(message, ex); return; } if (message == null) { continue; } try { var isMessageHandled = HandleMessage(message); if (receiveMode == ReceiveMode.PeekLock) { if (isMessageHandled) { message.Complete(); } else { message.Abandon(); } } } catch (Exception ex) { if (receiveMode == ReceiveMode.PeekLock) { message.Abandon(); } ExceptionOccured?.Invoke(message, ex); } Thread.Sleep(50); } }
private void InitConncection() { messagingFactory = MessagingFactory.CreateFromConnectionString(ConfigurationManager.ConnectionStrings["AzureSB"].ConnectionString); messagingFactory.RetryPolicy = new RetryExponential(TimeSpan.FromSeconds(1), TimeSpan.FromMinutes(5), 10); imageSender = messagingFactory.CreateMessageSender(ConfigurationManager.AppSettings["OutQ"]); statusSender = messagingFactory.CreateMessageSender(ConfigurationManager.AppSettings["StatusQ"]); configReciver = messagingFactory.CreateMessageReceiver(ConfigurationManager.AppSettings["InQ"]); }
public ConnectToTopic() { connectionString = "Endpoint=sb://nitprodevstd.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=bVW5y5kVXRbG4FU0g45OUuWELdsGWVLsongkRjWS+uk="; topicName = "nitorprodevstdtopic"; subscription1 = "nitorprodevstdtopicsub1"; messagingFactory = MessagingFactory.CreateFromConnectionString(connectionString); messageSender = messagingFactory.CreateMessageSender(topicName); messageReceiver = messagingFactory.CreateMessageReceiver(topicName + "/subscriptions/" + subscription1); options = new OnMessageOptions(); }
static void Main(string[] args) { Console.Write("Enter some subscription name: "); string name = Console.ReadLine(); var serviceNamespace = "msswit2013relay"; var issuerName = "owner"; var issuerSecret = "IqyIwa7gNjBO89HT+3Vd1CcoBbyibvcv6Hd92J+FtPg="; Uri uri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Empty); TokenProvider tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret); NamespaceManager namespaceManager = new NamespaceManager(uri, tokenProvider); if (!namespaceManager.TopicExists("MyTopic")) { namespaceManager.CreateTopic(new TopicDescription("MyTopic")); } Console.WriteLine("topic ready"); if (!namespaceManager.SubscriptionExists("MyTopic", "subscription-" + name)) { namespaceManager.CreateSubscription("MyTopic", "subscription-" + name); } Console.WriteLine("subscription ready"); MessagingFactory factory = MessagingFactory.Create(uri, tokenProvider); MessageReceiver receiver = factory.CreateMessageReceiver("MyTopic/subscriptions/subscription-" + name); while (true) { BrokeredMessage receivedMessage = receiver.Receive(); if (receivedMessage != null) { try { Console.WriteLine("label: {0}", receivedMessage.Label); Console.WriteLine("login: {0}", receivedMessage.Properties["login"]); Console.WriteLine("pass: {0}", receivedMessage.GetBody <ServiceBusTestMessage>().Password); receivedMessage.Complete(); } catch (Exception e) { receivedMessage.Abandon(); Console.WriteLine(e.Message); } } else { Thread.Sleep(new TimeSpan(0, 0, 10)); } } }
public string RecieveMesage() { //Receiving a message MessageReceiver testReceiver = _factory.CreateMessageReceiver(_queue); BrokeredMessage message = testReceiver.Receive(); String messageText = message.GetBody <string>(); message.Complete(); return(messageText); }
public MessageProcessor(string queueName, string serviceNameSpace, string issuer, string key) { // Create Token Provider and Service Uri var tokenProvider = TokenProvider.CreateSharedSecretTokenProvider(issuer, key); var serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNameSpace, string.Empty); // Create a messaging receiver _factory = MessagingFactory.Create(serviceUri, tokenProvider); _messageReceiver = _factory.CreateMessageReceiver(queueName); //_messageSender = _factory.CreateMessageSender(queueName); }
public MessageReceiver GetMessageReceiver(MessagingFactory factory, string queueSubscription) { try { return(factory.CreateMessageReceiver(queueSubscription)); } catch (Exception ex) { throw; } }
public ConnectToQueue() { connectionString = "Endpoint=sb://nitprodev.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=ITfvDogxy7Kuc/wbTPu1HP7g1Mh7eqSvtaP/E6y3HH0="; queueName = "nitprodevqueue"; messagingFactory = MessagingFactory.CreateFromConnectionString(connectionString); messageSender = messagingFactory.CreateMessageSender(queueName); messageReceiver = messagingFactory.CreateMessageReceiver(queueName); options = new OnMessageOptions(); var client = QueueClient.CreateFromConnectionString(connectionString, queueName); var deadQueue = QueueClient.CreateFromConnectionString(connectionString, QueueClient.FormatDeadLetterPath(client.Path)); }
public async Task StartAsync_CallsMessagingProviderToCreateReceiver() { MessageReceiver receiver = _messagingFactory.CreateMessageReceiver(_entityPath); _mockMessagingProvider.Setup(p => p.CreateMessageReceiver(_messagingFactory, _entityPath)).Returns(receiver); MessagingCommunicationException ex = await Assert.ThrowsAsync <MessagingCommunicationException>(async() => { await _listener.StartAsync(CancellationToken.None); }); Assert.Equal("No such host is known", ex.Message); _mockMessagingProvider.VerifyAll(); }
public async Task StartAsync_CallsMessagingProviderToCreateReceiver() { MessageReceiver receiver = _messagingFactory.CreateMessageReceiver(_entityPath); _mockMessagingProvider.Setup(p => p.CreateMessageReceiver(_messagingFactory, _entityPath)).Returns(receiver); MessagingCommunicationException ex = await Assert.ThrowsAsync <MessagingCommunicationException>(async() => { await _listener.StartAsync(CancellationToken.None); }); Assert.Equal("Unable to connect to Service Bus using HTTP connectivity mode.", ex.Message); _mockMessagingProvider.VerifyAll(); }
static void Main(string[] args) { TokenProvider token = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", "H+rYJ3XugZAx4AwBWbgkgiqBzdxiFOY2ZR9FicPK840="); Uri path = ServiceBusEnvironment.CreateServiceUri("sb", "ajaybus", ""); MessagingFactory factory = MessagingFactory.Create(path, token); MessageReceiver reciever = factory.CreateMessageReceiver("DetailmessageTopic/subscriptions/High"); BrokeredMessage msg; while ((msg = reciever.Receive()) != null) { Console.WriteLine("hello"); Console.WriteLine("Message:" + msg.GetBody <String>() + "\t Priority: " + msg.Properties["priority"]); msg.Complete(); } Console.WriteLine("The High Priority Queue completed"); reciever = factory.CreateMessageReceiver("DetailmessageTopic/subscriptions/Low"); while ((msg = reciever.Receive()) != null) { Console.WriteLine("hello"); Console.WriteLine("Message:" + msg.GetBody <String>() + "\t Priority: " + msg.Properties["priority"]); msg.Complete(); } Console.WriteLine("The Low Priority Queue completed"); }
/// <summary> /// Creates a <see cref="MessageReceiver"/> for the specified ServiceBus entity. /// </summary> /// <remarks> /// You can override this method to customize the <see cref="MessageReceiver"/>. /// </remarks> /// <param name="factory">The <see cref="MessagingFactory"/> to use.</param> /// <param name="entityPath">The ServiceBus entity to create a <see cref="MessageReceiver"/> for.</param> /// <returns></returns> public virtual MessageReceiver CreateMessageReceiver(MessagingFactory factory, string entityPath) { if (factory == null) { throw new ArgumentNullException("factory"); } if (string.IsNullOrEmpty(entityPath)) { throw new ArgumentNullException("entityPath"); } MessageReceiver receiver = factory.CreateMessageReceiver(entityPath); receiver.PrefetchCount = _config.PrefetchCount; return(receiver); }
public async Task ReceiveMessages() { messageReceiver = factory.CreateMessageReceiver(queuename); stopwatch.Restart(); stopwatch.Start(); for (int i = 0; i < numberOfMessages; i++) { Task.Factory.StartNew(ReceiveMessage); } var elapsedMilliseconds = stopwatch.ElapsedMilliseconds; Console.WriteLine("{0} messages received in {1} ms", numberOfMessages, elapsedMilliseconds); Console.WriteLine("Received {0} per second", numberOfMessages == 0 ? 0L : (1000 * (long)numberOfMessages) / (long)elapsedMilliseconds); }
static void Main(string[] args) { // *************************************************************************************** // This sample demonstrates how to use MessagePeek feature to look into the content of // Service bus entities (Queues , Subscriptions). // *************************************************************************************** Program.GetNamespaceAndCredentials(); MessagingFactory messagingFactory = MessagingFactory.CreateFromConnectionString(ServiceBusConnectionString); MessageReceiver messageReciever = messagingFactory.CreateMessageReceiver(Program.ServiceBusentityPath); BrokeredMessage msg; while (true) { msg = messageReciever.Peek(); if (msg != null) { Console.WriteLine("{0} {1} - {2} - {3}", msg.EnqueuedTimeUtc.ToLocalTime().ToShortDateString(), msg.EnqueuedTimeUtc.ToLocalTime().ToLongTimeString(), msg.SequenceNumber, msg.Label); var listViewItems = msg.Properties.Select(p => new[] { p.Key, p.Value.ToString() }).ToArray(); for (int propIndex = 0; propIndex < listViewItems.Length; propIndex++) { Console.Write("{0}: {1}\t", listViewItems[propIndex][0], listViewItems[propIndex][1]); } Stream stream = msg.GetBody <Stream>(); if (stream != null) { StreamReader reader = new StreamReader(stream); string text = reader.ReadToEnd(); if (text != null) { Console.WriteLine("\n{0}\n", text); } } } else { break; } } messagingFactory.Close(); Console.WriteLine("Press [Enter] to quit..."); Console.ReadLine(); }
public void NewThread() { string connectionString = ""; string topicPath = ""; string subscriptionName = ""; MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connectionString); var deadLetterPath = SubscriptionClient.FormatDeadLetterPath(topicPath, subscriptionName); var dlqMessageReceiver = factory.CreateMessageReceiver(deadLetterPath, ReceiveMode.ReceiveAndDelete); var thr = Thread.CurrentThread.Name; int messageBatchSize = 100; while (dlqMessageReceiver.ReceiveBatch(messageBatchSize) != null) { Console.Write($"{thr}#"); } }
public async Task ReceiveMessages() { messageReceiver = factory.CreateMessageReceiver(queuename); stopwatch.Restart(); stopwatch.Start(); for (int i = 0; i < numberOfMessages; i++) { var message = await messageReceiver.ReceiveAsync(); await messageReceiver.CompleteAsync(message.LockToken); } var elapsedMilliseconds = stopwatch.ElapsedMilliseconds; Console.WriteLine("{0} messages received in {1} ms", numberOfMessages, elapsedMilliseconds); Console.WriteLine("Received {0} per second", numberOfMessages == 0 ? 0L : (1000 * (long)numberOfMessages) / (long)elapsedMilliseconds); }
public async Task ReceiveMessages() { List <Task> tasks = new List <Task>(); messageReceiver = factory.CreateMessageReceiver(queuename); stopwatch.Restart(); stopwatch.Start(); for (int i = 0; i < numberOfMessages; i++) { tasks.Add(Task.Factory.StartNew(ReceiveMessage)); } Task.WaitAll(tasks.ToArray()); var elapsedMilliseconds = stopwatch.ElapsedMilliseconds; Console.WriteLine("{0} messages received in {1} ms", numberOfMessages, elapsedMilliseconds); Console.WriteLine("Received {0} per second", numberOfMessages == 0 ? 0L : (1000 * (long)numberOfMessages) / (long)elapsedMilliseconds); }
static void Main(string[] args) { string connectionString = ConfigurationManager.AppSettings["ServiceBusConnection"]; MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connectionString); var deadLetterPath = QueueClient.FormatDeadLetterPath("trade-input"); var dlqReceiver = factory.CreateMessageReceiver(deadLetterPath, ReceiveMode.ReceiveAndDelete); BrokeredMessage message; while ((message = dlqReceiver.Receive()) != null) { string body; using (var stream = message.GetBody <Stream>()) using (var streamReader = new StreamReader(stream, Encoding.UTF8)) { body = streamReader.ReadToEnd(); } Console.WriteLine($"Message Received {body}"); } Console.Read(); }
internal Binding(MessagingFactory messagingFactory, NamespaceManager namespaceManager, AzureQueueMqSettings settings, Action <string> logMessage, Action <string> logError) { var queueName = settings.QueueNameBuilderForSubscriber(typeof(T)); _receiver = messagingFactory.CreateMessageReceiver(queueName, ReceiveMode.PeekLock); _excludeQueuesFromLogging = new LoggingConfiguration().ExcludeQueuesFromLogging(); if (!namespaceManager.QueueExists(queueName)) { var queueDescription = new QueueDescription(queueName); namespaceManager.CreateQueue(settings.QueueBuilderConfig(queueDescription, typeof(T))); } _receiver.OnMessage(message => { try { var bodyStream = message.GetBody <Stream>(); using (var reader = new StreamReader(bodyStream)) { var body = reader.ReadToEnd(); if (!_excludeQueuesFromLogging.Contains(queueName)) { logMessage($"Received '{queueName}': {body}"); } Subject.OnNext(JObject.Parse(body)["data"].ToObject <T>()); } } catch (Exception ex) { logError($"Message {queueName}': {message} -> consumer error: {ex}"); } }, new OnMessageOptions { AutoComplete = true }); }
private static async Task <ReadResult> DoReadOperation(string connectionString, string path, TimeSpan timeout, bool useCached, Func <MessageReceiver, Task <ReadResult> > operation) { MessagingFactory mfactory = null; MessageReceiver requestClient = null; try { if (useCached) { requestClient = ServiceBusMessagingFactory.Instance.GetMessageReceiver(connectionString, path, timeout); } else { mfactory = ServiceBusMessagingFactory.CreateMessagingFactoryWithTimeout(connectionString, timeout); requestClient = mfactory.CreateMessageReceiver(path); } return(await operation.Invoke(requestClient).ConfigureAwait(false)); } finally { requestClient?.Close(); mfactory?.Close(); } }
/// <summary> /// Using a <see cref="Task"/>, clears all dead letters from the topic and subscription of the /// provided <paramref name="topicName"/> and <paramref name="topicSubscriptionName"/>. /// </summary> /// <param name="topicName">The name of the topic.</param> /// <param name="topicSubscriptionName">The name of the subscription.</param> /// <returns></returns> protected virtual CancellationTokenSource CleanUpDeadLetters(string topicName, string topicSubscriptionName) { var brokeredMessageRenewCancellationTokenSource = new CancellationTokenSource(); IDictionary <string, string> telemetryProperties = new Dictionary <string, string> { { "Type", "Azure/Servicebus" } }; int lockIssues = 0; Action <BrokeredMessage, IMessage> leaveDeadlLetterInQueue = (deadLetterBrokeredMessage, deadLetterMessage) => { // Remove message from queue try { deadLetterBrokeredMessage.Abandon(); lockIssues = 0; } catch (MessageLockLostException) { lockIssues++; Logger.LogWarning(string.Format("The lock supplied for abandon for the skipped dead-letter message '{0}' is invalid.", deadLetterBrokeredMessage.MessageId)); } Logger.LogDebug(string.Format("A dead-letter message of type {0} arrived with the id '{1}' but left in the queue due to settings.", deadLetterMessage.GetType().FullName, deadLetterBrokeredMessage.MessageId)); }; Action <BrokeredMessage> removeDeadlLetterFromQueue = deadLetterBrokeredMessage => { // Remove message from queue try { deadLetterBrokeredMessage.Complete(); lockIssues = 0; } catch (MessageLockLostException) { lockIssues++; Logger.LogWarning(string.Format("The lock supplied for complete for the skipped dead-letter message '{0}' is invalid.", deadLetterBrokeredMessage.MessageId)); } Logger.LogDebug(string.Format("A dead-letter message arrived with the id '{0}' but was removed as processing was skipped due to settings.", deadLetterBrokeredMessage.MessageId)); }; Task.Factory.StartNewSafely(() => { int loop = 0; while (!brokeredMessageRenewCancellationTokenSource.Token.IsCancellationRequested) { lockIssues = 0; MessagingFactory factory = MessagingFactory.CreateFromConnectionString(ConnectionString); string deadLetterPath = SubscriptionClient.FormatDeadLetterPath(topicName, topicSubscriptionName); MessageReceiver client = factory.CreateMessageReceiver(deadLetterPath, ReceiveMode.PeekLock); IEnumerable <BrokeredMessage> brokeredMessages = client.ReceiveBatch(1000); foreach (BrokeredMessage brokeredMessage in brokeredMessages) { if (lockIssues > 10) { break; } try { Logger.LogDebug(string.Format("A dead-letter message arrived with the id '{0}'.", brokeredMessage.MessageId)); string messageBody = brokeredMessage.GetBody <string>(); // Closure protection BrokeredMessage message = brokeredMessage; try { AzureBusHelper.ReceiveEvent ( messageBody, @event => { bool isRequired = BusHelper.IsEventRequired(@event.GetType()); if (!isRequired) { removeDeadlLetterFromQueue(message); } else { leaveDeadlLetterInQueue(message, @event); } return(true); }, string.Format("id '{0}'", brokeredMessage.MessageId), () => { removeDeadlLetterFromQueue(message); }, () => { } ); } catch { AzureBusHelper.ReceiveCommand ( messageBody, command => { bool isRequired = BusHelper.IsEventRequired(command.GetType()); if (!isRequired) { removeDeadlLetterFromQueue(message); } else { leaveDeadlLetterInQueue(message, command); } return(true); }, string.Format("id '{0}'", brokeredMessage.MessageId), () => { removeDeadlLetterFromQueue(message); }, () => { } ); } } catch (Exception exception) { TelemetryHelper.TrackException(exception, null, telemetryProperties); // Indicates a problem, unlock message in queue Logger.LogError(string.Format("A dead-letter message arrived with the id '{0}' but failed to be process.", brokeredMessage.MessageId), exception: exception); try { brokeredMessage.Abandon(); } catch (MessageLockLostException) { lockIssues++; Logger.LogWarning(string.Format("The lock supplied for abandon for the skipped dead-letter message '{0}' is invalid.", brokeredMessage.MessageId)); } } } client.Close(); if (loop++ % 5 == 0) { loop = 0; Thread.Yield(); } else { Thread.Sleep(500); } } try { brokeredMessageRenewCancellationTokenSource.Dispose(); } catch (ObjectDisposedException) { } }, brokeredMessageRenewCancellationTokenSource.Token); return(brokeredMessageRenewCancellationTokenSource); }
/// <summary> /// Creates a <see cref="MessageReceiver"/> for the specified ServiceBus entity. /// </summary> /// <remarks> /// You can override this method to customize the <see cref="MessageReceiver"/>. /// </remarks> /// <param name="factory">The <see cref="MessagingFactory"/> to use.</param> /// <param name="entityPath">The ServiceBus entity to create a <see cref="MessageReceiver"/> for.</param> /// <returns></returns> public virtual MessageReceiver CreateMessageReceiver(MessagingFactory factory, string entityPath) { if (factory == null) { throw new ArgumentNullException("factory"); } if (string.IsNullOrEmpty(entityPath)) { throw new ArgumentNullException("entityPath"); } MessageReceiver receiver = factory.CreateMessageReceiver(entityPath); receiver.PrefetchCount = _config.PrefetchCount; return receiver; }
static async Task RunDeviceEndpoint(IPEndPoint deviceEP, MessagingFactory messagingFactory) { var deviceServer = new TcpListener(deviceEP); deviceServer.Start(10); try { do { TcpClient connection = await deviceServer.AcceptTcpClientAsync(); if (connection != null) { try { var pendingSessions = new Queue<string>(); connection.NoDelay = true; // flush writes immediately to the wire connection.ReceiveTimeout = timeout; NetworkStream deviceConnectionStream = connection.GetStream(); var readBuffer = new byte[64]; if (await deviceConnectionStream.ReadAsync(readBuffer, 0, 4) == 4) { int deviceId = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(readBuffer, 0)); try { Task<BrokeredMessage> queueReceive = null; Task<int> socketRead = null; Task pingDelay = null; var cancelPing = new CancellationTokenSource(); // set up the receiver for the per-device queue and senbder for the response queue var deviceQueueReceiver = messagingFactory.CreateMessageReceiver(string.Format("dev-{0:X8}", deviceId), ReceiveMode.PeekLock); var responseQueueSender = messagingFactory.CreateMessageSender(string.Format("ingress")); do { // receive from the queue queueReceive = queueReceive ?? deviceQueueReceiver.ReceiveAsync(); // read from the socket socketRead = socketRead ?? deviceConnectionStream.ReadAsync(readBuffer, 0, 1); // ping delay pingDelay = pingDelay ?? Task.Delay(TimeSpan.FromSeconds(235), cancelPing.Token); // wait for any of the four operations (including completion) to be done var completedTask = await Task.WhenAny(queueReceive, socketRead, pingDelay, ClosingEvent.Task); if (completedTask == socketRead) { try { // read from the socket completed and not a ping if (socketRead.Result == 1) { if (readBuffer[0] != PingFrame[0]) { await responseQueueSender.SendAsync(new BrokeredMessage() { SessionId = pendingSessions.Dequeue(), Properties = {{"Ack", (int) readBuffer[0]}} }); } } else { // no more data from the socket. Break out of the loop. break; } } finally { socketRead = null; } } else if (completedTask == queueReceive) { try { // read from the queue completed var message = queueReceive.Result; if (message != null) { var command = message.Properties["Cmd"] as string; if (command != null) { switch (command.ToUpperInvariant()) { case "ON": pendingSessions.Enqueue(message.ReplyToSessionId); await deviceConnectionStream.WriteAsync(OnFrame, 0, OnFrame.Length); await message.CompleteAsync(); cancelPing.Cancel(); break; case "OFF": pendingSessions.Enqueue(message.ReplyToSessionId); await deviceConnectionStream.WriteAsync(OffFrame, 0, OffFrame.Length); await message.CompleteAsync(); cancelPing.Cancel(); break; } } } } finally { queueReceive = null; } } else if (completedTask == pingDelay) { try { if (pingDelay.IsCanceled) { cancelPing = new CancellationTokenSource(); } else { await deviceConnectionStream.WriteAsync(PingFrame, 0, PingFrame.Length); } } finally { pingDelay = null; } } else { // closing event was fired break; } } while (true); } finally { connection.Close(); } } else { connection.Close(); } } catch (SocketException se) { // log Trace.TraceError(se.Message); connection.Close(); } catch (IOException e) { Trace.TraceError(e.Message); connection.Close(); } catch (Exception e) { Trace.TraceError(e.Message); } } } while (true); } finally { deviceServer.Stop(); } }