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);
}
