private void InitializeTopicSubscription() { var topicName = ConfigurationManager.AppSettings["topic"]; var namespaceManager = NamespaceManager.Create(); var subscription = new SubscriptionDescription(topicName, SubscriptionName); if (!namespaceManager.SubscriptionExists(topicName, SubscriptionName)) { namespaceManager.CreateSubscription(subscription); } this.subscriber = SubscriptionClient.Create(topicName, SubscriptionName, ReceiveMode.ReceiveAndDelete); this.subscriber.OnMessage(msg => { var data = msg.GetBody <StateModelData>(); // change barcode value this.barcodeSeparator = data.CurrentSettings.BarcodeValue; // dispose prev timer and create the new timer to start the method immediately this.timer.Dispose(); this.timer = this.CreateTimer(); }); }
public void ReceiveOrder() { Console.ForegroundColor = ConsoleColor.Magenta; Console.WriteLine("Receiving information from {0} subscriptions", InfrastructureManagement.TopicPath); //loop to all topic subscriptions foreach (var subsDescription in InfrastructureManagement.Namespace.GetSubscriptions(InfrastructureManagement.TopicPath)) { Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Receiving information from subscription {0} ...", subsDescription.Name); //Create subscription client var subsClient = SubscriptionClient.Create(InfrastructureManagement.TopicPath, subsDescription.Name); //Receive all the messages from the subscription Console.ForegroundColor = ConsoleColor.Green; //read subscription message ReadMessageValue(subsClient); subsClient.Close(); } Console.ResetColor(); }
static void Main(string[] args) { Console.Title = "Expensive Purchases Subscriber"; SubscriptionClient subscriptionClient = SubscriptionClient.Create("productsalestopic", "ExpensivePurchases"); // Continuously process messages received from the ExpensivePurchases subscription while (true) { BrokeredMessage message = subscriptionClient.Receive(); if (message != null) { try { Console.WriteLine("Received purchase: Message id: {0}, Product name: {1}, Product price: {2}.", message.MessageId, message.Properties["ProductName"], message.Properties["ProductPrice"]); // Remove printed message from subscription message.Complete(); } catch (Exception) { // In case of an error, unlock the message in subscription message.Abandon(); } } } }
private static void ReceiveAndNotify() { SubscriptionClient agentSubscriptionClient = SubscriptionClient.Create("tempdata", "AgentSubscription"); BrokeredMessage message = null; var toastMessage = @"<toast activationType='foreground' launch='args'> <visual><binding template=""ToastGeneric""> <text id=""1"">{messagepayload}</text> </binding></visual> <actions> <action content='Dismiss' activationType='foreground' arguments='check'/> <action content='Take Action' activationType='foreground' arguments='cancel'/> </actions></toast>"; while (true) { try { //receive messages from Agent Subscription message = agentSubscriptionClient.Receive(); if (message != null) { Console.WriteLine("\nReceiving message from AgentSubscription..."); //The Storm bolt converts string to stream. Need to convert back. var stream = message.GetBody <Stream>(); StreamReader reader = new StreamReader(stream); string messageBody = reader.ReadToEnd(); toastMessage = toastMessage.Replace("{messagepayload}", messageBody); //Send notification SendNotificationAsync(toastMessage); // Remove message from subscription message.Complete(); } else { //no more messages in the subscription break; } } catch (MessagingException e) { if (!e.IsTransient) { Console.WriteLine(e.Message); throw; } else { HandleTransientErrors(e); } } } }
public async Task <ICollection <BrokeredMessage> > GetMessagesAsync(string subscriptionName) { if (string.IsNullOrEmpty(subscriptionName)) { throw new DSWException(SUBSCRIPTION_NOT_INITIALIZE, null, DSWExceptionCode.SS_Mapper); } SubscriptionClient client = SubscriptionClient.Create(TopicName, subscriptionName, ReceiveMode.ReceiveAndDelete); return((await client.ReceiveBatchAsync(1)).ToList()); }
/// <summary> /// ReceiveMessagesFromSubscription installs the receive handler. /// </summary> /// <param name="topicName"></param> /// <param name="subscriptionFilter"></param> public void ReceiveMessagesFromSubscription(string topicName, string subscriptionFilter) { try { Task listener = Task.Factory.StartNew(() => { // You only need to set up the below once. Client = SubscriptionClient.Create(TopicName, SubscriptionName); var options = new OnMessageOptions(); options.AutoComplete = false; options.ExceptionReceived += LogErrors; try { Client.OnMessage((message) => { try { Type messageType = Type.GetType(message.ContentType); Stream stream = message.GetBody <Stream>(); if (TryDeserialization(stream, messageType, out object o)) { Message?.Invoke(this, new OnMessageEventArgs() { Content = o, ContentType = messageType }); } message.Complete(); // Remove message from subscription. } catch (Exception ex) { logger.Trace(ex.Message); message.Abandon(); // Failed. Leave the message for retry or max deliveries is exceeded and it dead letters. } }, options); } catch (Exception exe) { logger.Error(exe.Message); } CompletedResetEvent.WaitOne(); }); } catch (Exception e) { logger.Error(e.Message); } }
private void SetupPingNowListener() { var nsm = NamespaceManager.Create(); if (!nsm.SubscriptionExists(TopicName, SubscriptionName)) { nsm.CreateSubscription(TopicName, SubscriptionName, new SqlFilter("sys.To = 'FileSender' AND ActionName = 'PingNow'")); } var client = SubscriptionClient.Create(TopicName, SubscriptionName); client.OnMessage(ProcessPingNow); }
public SettingsManager(BarcodeAnalyzer analyzer) { _analyzer = analyzer; var nsm = NamespaceManager.Create(); if (!nsm.SubscriptionExists(TopicName, SubscriptionName)) { nsm.CreateSubscription(TopicName, SubscriptionName, new SqlFilter("sys.To = 'FileSender' AND ActionName = 'SetTerminateWord'")); } var client = SubscriptionClient.Create(TopicName, SubscriptionName); client.OnMessage(ProcessMessage); }
public PingReceiver() { var nsm = NamespaceManager.Create(); if (nsm.SubscriptionExists(TopicName, SubscriptionName)) { nsm.DeleteSubscription(TopicName, SubscriptionName); } nsm.CreateSubscription(TopicName, SubscriptionName, new SqlFilter("sys.To = 'CentralQueueManager' AND ActionName = 'Ping'")); var client = SubscriptionClient.Create(TopicName, SubscriptionName); client.OnMessage(ProcessMessage); }
public ServiceBusSettingsMessageReceiver() { var connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString"); var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString); if (!namespaceManager.TopicExists("settingtopic")) { namespaceManager.CreateTopic("settingtopic"); } if (!namespaceManager.SubscriptionExists("settingtopic", Environment.MachineName)) { namespaceManager.CreateSubscription("settingtopic", Environment.MachineName); } _subscriptionClient = SubscriptionClient.Create("settingtopic", Environment.MachineName); }
private void SubscribeToSettings() { var client = SubscriptionClient.Create(ClientSettingstopic, ClientSettingsSubs); do { BrokeredMessage message; while ((message = client.Receive(TimeSpan.FromSeconds(5))) != null) { if (_stopEvent.WaitOne(TimeSpan.Zero)) { return; } var data = message.GetBody <ClientSetting>(); ConfigurationManager.AppSettings["NextPageTimeout"] = data.NextFileTimeout + ""; client.Complete(message.LockToken); } }while (WaitHandle.WaitAny(new WaitHandle[] { _stopEvent }, 1000) != 0); client.Close(); }
//Receive message from Fascia Topic public static void ReceiveMessages() { string TopicName = CloudConfigurationManager.GetSetting("AlertTopicName"); string SubscriptionName = CloudConfigurationManager.GetSetting("SubscriptionName"); bool SMSAlert = Convert.ToBoolean(CloudConfigurationManager.GetSetting("SMSAlert")); bool PushNotification = Convert.ToBoolean(CloudConfigurationManager.GetSetting("PushNotification")); BrokeredMessage message = null; // For ReceiveAndDelete mode, where applications require "best effort" delivery of messages SubscriptionClient alertSubscriptionClient = SubscriptionClient.Create(TopicName, SubscriptionName, ReceiveMode.ReceiveAndDelete); while (true) { try { message = alertSubscriptionClient.Receive(TimeSpan.FromSeconds(5)); if (message != null) { string messageBody = message.GetBody <string>(); if (PushNotification) { PushGCMNotificationAsync(messageBody); } if (SMSAlert) { SendTwilioSMSNotification(messageBody); } } else { break; } } catch (MessagingException e) { Console.WriteLine(e.Message); } } alertSubscriptionClient.Close(); }
private async Task InitializeSubscriptionAsync(string subscriptionName, string correlationId, string defaultFilter, Action <BrokeredMessage> callback) { TopicDescription topic = await NamespaceManager.GetTopicAsync(TopicName); if (await NamespaceManager.SubscriptionExistsAsync(topic.Path, subscriptionName)) { return; } if (!_subscriptionClient.ContainsKey(subscriptionName)) { RuleDescription defaultRuleDescription = new RuleDescription() { Filter = new SqlFilter(string.Concat(string.Format(SUBSCRIPTION_CORRELATION_FILTER, correlationId), " AND ", defaultFilter)), Name = RuleDescription.DefaultRuleName }; SubscriptionDescription subscriptionDescription = new SubscriptionDescription(topic.Path, subscriptionName) { AutoDeleteOnIdle = ServiceBusConfiguration.AutoDeleteOnIdle, DefaultMessageTimeToLive = ServiceBusConfiguration.DefaultMessageTimeToLive, EnableBatchedOperations = true, EnableDeadLetteringOnFilterEvaluationExceptions = true, EnableDeadLetteringOnMessageExpiration = false, LockDuration = ServiceBusConfiguration.LockDuration, MaxDeliveryCount = ServiceBusConfiguration.MaxDeliveryCount, Name = subscriptionName }; subscriptionDescription = await NamespaceManager.CreateSubscriptionAsync(subscriptionDescription, defaultRuleDescription); _logger.WriteInfo(new LogMessage($"Subscription {subscriptionName} in topic {TopicName} has been created"), LogCategories); if (callback != null) { SubscriptionClient client = SubscriptionClient.Create(TopicName, subscriptionName, ReceiveMode.PeekLock); client.OnMessageAsync(async(message) => await EvaluateMessageAsync(message, callback), _messageOptions); _logger.WriteInfo(new LogMessage($"Subscription {subscriptionName} has been activated"), LogCategories); _subscriptionClient.Add(subscriptionName, client); } } }
public void Start() { string topicName = ConfigurationManager.AppSettings["SERVICEBUS_TOPICNAME"]; string subsriptionName = ConfigurationManager.AppSettings["SERVICEBUS_LEADSCORESUBSCRIPTION_NAME"]; pubSubService.Initialize(); Logger.Current.Informational("subscription:" + subsriptionName); Logger.Current.Informational("Connection string:" + ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]); this.ProcessMessage(); client = SubscriptionClient.Create(topicName, subsriptionName); Logger.Current.Informational("Service bus message queue client created successfully."); observable = Observable.Create <BrokeredMessage>( observer => { client.OnMessage(observer.OnNext, new OnMessageOptions() { AutoComplete = false, AutoRenewTimeout = new TimeSpan(0, 0, 1, 0, 0) }); return(Disposable.Empty); }).Publish().RefCount(); observable.Subscribe(x => { Logger.Current.Informational("Recieved message. BrokeredMessageId:" + x.MessageId); x.RenewLock(); var serializedMessage = x.GetBody <string>(); Message message = JsonConvert.DeserializeObject <Message>(serializedMessage); message.MessageId = x.MessageId; message.LockToken = x.LockToken; Logger.Current.Informational("Message recieved successfully, details:" + message.ToString()); this.Feed(message); }); }
public AzureQueueClient(string clientUniqueName) { NamespaceManager namespaceManager = NamespaceManager.Create(); var topicName = ClientConstants.SettingTopicName; try { if (namespaceManager.TopicExists(topicName)) { if (namespaceManager.SubscriptionExists(topicName, clientUniqueName)) { namespaceManager.DeleteSubscription(topicName, clientUniqueName); } namespaceManager.CreateSubscription(topicName, clientUniqueName); } } catch (Exception e) { // ignored } _subscibtionClient = SubscriptionClient.Create(topicName, clientUniqueName, ReceiveMode.ReceiveAndDelete); }
private async Task InitializeSubscriptionAsync(string subscriptionName, string filter = "") { TopicDescription topic = await NamespaceManager.GetTopicAsync(TopicName); if (!await NamespaceManager.SubscriptionExistsAsync(topic.Path, subscriptionName)) { return; } if (!_subscriptionClient.ContainsKey(subscriptionName)) { SubscriptionClient client = SubscriptionClient.Create(TopicName, subscriptionName, ReceiveMode.PeekLock); if (!string.IsNullOrEmpty(filter)) { client.AddRule(new RuleDescription { Name = "localrule", Filter = new SqlFilter(filter), }); } _logger.WriteInfo(new LogMessage(string.Concat("Subscription ", subscriptionName, " has been activated")), LogCategories); _subscriptionClient.Add(subscriptionName, client); } }
private static void ReceiveMessages() { // For PeekLock mode (default) where applications require "at least once" delivery of messages SubscriptionClient agentSubscriptionClient = SubscriptionClient.Create(TopicName, "AgentSubscription"); BrokeredMessage message = null; while (true) { try { //receive messages from Agent Subscription message = agentSubscriptionClient.Receive(TimeSpan.FromSeconds(5)); if (message != null) { Console.WriteLine("\nReceiving message from AgentSubscription..."); Console.WriteLine(string.Format("Message received: Id = {0}, Body = {1}", message.MessageId, message.GetBody <string>())); // Further custom message processing could go here... message.Complete(); } else { //no more messages in the subscription break; } } catch (MessagingException e) { if (!e.IsTransient) { Console.WriteLine(e.Message); throw; } else { HandleTransientErrors(e); } } } // For ReceiveAndDelete mode, where applications require "best effort" delivery of messages SubscriptionClient auditSubscriptionClient = SubscriptionClient.Create(TopicName, "AuditSubscription", ReceiveMode.ReceiveAndDelete); while (true) { try { message = auditSubscriptionClient.Receive(TimeSpan.FromSeconds(5)); if (message != null) { Console.WriteLine("\nReceiving message from AuditSubscription..."); Console.WriteLine(string.Format("Message received: Id = {0}, Body = {1}", message.MessageId, message.GetBody <string>())); // Further custom message processing could go here... } else { //no more messages in the subscription break; } } catch (MessagingException e) { if (!e.IsTransient) { Console.WriteLine(e.Message); throw; } } } agentSubscriptionClient.Close(); auditSubscriptionClient.Close(); }
public MessageSubscriber() { Client = SubscriptionClient.Create(TopicName, SubscriptionName); Client.AddRule(new RuleDescription("testrule")); }
public SubscriptionClient GetSubscriptionClient(string subscriptionName) { var client = SubscriptionClient.Create(TOPIC_NAME, subscriptionName, ReceiveMode.ReceiveAndDelete); return(client); }