public static void Main(string[] args)
{
var client = TopicClient.CreateFromConnectionString(SenderConnectionString, TopicName);
var message = new BrokeredMessage("Aliq Server to Aliq Worker, over!");
message.Properties["aliqcomms"] = "aliqserverbroadcast";
client.Send(message);
Console.WriteLine(String.Format("Message body: {0}", message.GetBody <String>()));
Console.WriteLine(String.Format("Message id: {0}", message.MessageId));
Console.ReadKey();
// listen to messages from the aliq server
var workerBroadcastListener = SubscriptionClient.CreateFromConnectionString(ListenerConnectionString, TopicName, "aliqworkernotifications", ReceiveMode.ReceiveAndDelete);
workerBroadcastListener.OnMessage((serverMessage) =>
{
Console.WriteLine(String.Format("Message body: {0}", serverMessage.GetBody <String>()));
Console.WriteLine(String.Format("Message id: {0}", serverMessage.MessageId));
});
Console.WriteLine("Message successfully sent! Press ENTER to exit program");
Console.ReadLine();
}
public string send()
{
// Create a Long running task to do an infinite loop which will keep sending the server time
// to the clients every 3 seconds.
// string msgTopic = string.Empty;
int i = 0;
string msgTopic = string.Empty;
while (true)
{
string timeNow = DateTime.Now.ToString();
////Sending the server time to all the connected clients on the client method SendServerTime()
//Clients.All.SendServerTime(timeNow);
//string msgTopic = servicebus();
var subClient = SubscriptionClient.CreateFromConnectionString(_conn, _topic, "test");
subClient.OnMessage(m =>
{
msgTopic = m.Properties["Name"].ToString();
});
if (!string.IsNullOrEmpty(msgTopic))
{
return(msgTopic);
}
Task.Delay(3000);
}
}
private void CreateServiceBusMessagingEntities()
{
var wasServiceBusConnectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.WarehouseAvailableStock");
var wasSubscriptionName = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.WarehouseAvailableStock.StockQuantitySubscription");
//var vccSubscriptionName = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.WarehouseAvailableStock.VariantSkuMapSubscription");
var wasTopicPath = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.WarehouseAvailableStock.TopicPath");
var stockQuantityServiceBusConnectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.StockQuantity");
var discardedEventsSubscriptionName = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.StockQuantity.DiscardedEventsSubscription");
var stockQuantityTopicPath = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.StockQuantity.TopicPath");
var discardedEventSubscriptionClient = SubscriptionClient.CreateFromConnectionString(stockQuantityServiceBusConnectionString, stockQuantityTopicPath, discardedEventsSubscriptionName);
// Set up Subscription Rules & Filters
var isDiscardedRuleDescription = new RuleDescription("IsDiscarded");
isDiscardedRuleDescription.Filter = new SqlFilter("IsDiscarded = 1");
discardedEventSubscriptionClient.RemoveRule(RuleDescription.DefaultRuleName);
discardedEventSubscriptionClient.RemoveRule(isDiscardedRuleDescription.Name);
discardedEventSubscriptionClient.AddRule(isDiscardedRuleDescription);
_maximumConcurrency = Convert.ToInt16(CloudConfigurationManager.GetSetting("MaximumConcurrency"));
_warehouseAvailableStockChangedReceiver = new WarehouseAvailableStockChangedReceiver(_maximumConcurrency, wasServiceBusConnectionString, wasSubscriptionName, wasTopicPath, _topicClient, _stockQuantityAggregateStore, _skuVariantCacheManager, _telemetryClient);
//_variantCopyCompletedReceiver = new VariantCopyCompletedReceiver(3, wasServiceBusConnectionString, vccSubscriptionName, wasTopicPath, _topicClient, _stockQuantityAggregateStore, _telemetryClient);
}
public static void Initialize()
{
if (null == OrdersTopicClient)
{
try
{
string connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBusTopics.ConnectionString");
// string connectionString = RoleEnvironment.GetConfigurationSettingValue("Microsoft.ServiceBusTopics.ConnectionString");
var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.TopicExists("OrderTopic"))
{
namespaceManager.CreateTopic("OrderTopic");
}
if (!namespaceManager.SubscriptionExists("OrderTopic", "OrderMessages"))
{
namespaceManager.CreateSubscription("OrderTopic", "OrderMessages");
}
// Initialize the connection to Service Bus Topics
OrdersTopicClient = TopicClient.CreateFromConnectionString(connectionString, "OrderTopic");
SubClient = SubscriptionClient.CreateFromConnectionString(connectionString, "OrderTopic", "OrderMessages");
}
catch (Exception ex)
{
string str = ex.Message;
}
}
}
public void RunSignalRBridgeLoop()
{
InitializeTopic();
var hub = GlobalHost.ConnectionManager
.GetHubContext <SignalRNotificationHub>();
SubscriptionClient startedJobsClient =
SubscriptionClient.CreateFromConnectionString(_connectionString,
_notificationTopicName,
GlobalConstants.SERVICEBUS_INTERNAL_SUBSCRIPTION_JOBSTARTED);
SubscriptionClient inProgressJobsClient =
SubscriptionClient.CreateFromConnectionString(_connectionString,
_notificationTopicName,
GlobalConstants.SERVICEBUS_INTERNAL_SUBSCRIPTION_JOBPROGRESS);
SubscriptionClient finishedJobsClient =
SubscriptionClient.CreateFromConnectionString(_connectionString,
_notificationTopicName,
GlobalConstants.SERVICEBUS_INTERNAL_SUBSCRIPTION_JOBFINISHED);
SubscriptionClient cancelledJobsClient =
SubscriptionClient.CreateFromConnectionString(_connectionString,
_notificationTopicName,
GlobalConstants.SERVICEBUS_INTERNAL_SUBSCRIPTION_JOBCANCELLED);
_signalRNotificationHandler = new ProgressNotificationHandler();
startedJobsClient.OnMessage(HandleNotificationMessage);
inProgressJobsClient.OnMessage(HandleNotificationMessage);
finishedJobsClient.OnMessage(HandleNotificationMessage);
cancelledJobsClient.OnMessage(HandleNotificationMessage);
}
public async Task Run(string connectionString)
{
this.sendClient = TopicClient.CreateFromConnectionString(connectionString, BasicTopicName);
this.subscription1Client = SubscriptionClient.CreateFromConnectionString(connectionString, BasicTopicName, "Subscription1");
this.subscription2Client = SubscriptionClient.CreateFromConnectionString(connectionString, BasicTopicName, "Subscription2");
this.subscription3Client = SubscriptionClient.CreateFromConnectionString(connectionString, BasicTopicName, "Subscription3");
this.InitializeReceiver(this.subscription1Client, ConsoleColor.Cyan);
this.InitializeReceiver(this.subscription2Client, ConsoleColor.Green);
this.InitializeReceiver(this.subscription3Client, ConsoleColor.Yellow);
await this.SendMessagesAsync();
await Task.WhenAny(
Task.Run(() => Console.ReadKey()),
Task.Delay(TimeSpan.FromSeconds(10))
);
await this.subscription1Client.CloseAsync();
await this.subscription2Client.CloseAsync();
await this.subscription3Client.CloseAsync();
}
public void ConnectOrDisconnect(string username)
{
bool isConnecting = !IsConnected;
IsConnected = !IsConnected;
if (isConnecting)
{
//let´s create a new SenderID
_senderId = Guid.NewGuid();
var subscription = _busClient.CreateSubscription(_topicName, _senderId.ToString());
//The subscription will delete itself when iddle more than 5 minutes!
//That will be used case the application crashes
subscription.AutoDeleteOnIdle = new TimeSpan(0, 5, 0);
//Now we will use the subscription we just created and will create a Subscription Client
//The idea is to print all messages that we receive!
_currentSubscription = SubscriptionClient.CreateFromConnectionString(_connectionString, _topicName, _senderId.ToString());
_currentSubscription.OnMessage(WhenMessageArrives);
//Sending has joined message
Send("**just joined**");
}
else
{
//Close subscription Client
_currentSubscription.Close();
//Then Remove it
_busClient.DeleteSubscription(_topicName, _senderId.ToString());
}
}
public void InitialiseTopic()
{
ServicePointManager.DefaultConnectionLimit = 12;
string connectionString = CloudConfigurationManager.GetSetting("ServiceBus.TopicConnectionString");
_topicClient = SubscriptionClient.CreateFromConnectionString(connectionString, "recreateindex", "WebRoles");
Task.Run(() =>
{
_topicClient.OnMessage(async receivedMessage =>
{
var sequenceNumber = receivedMessage.SequenceNumber;
try
{
await _throttling.Execute(async() => ReCreateSearcher());
}
catch (Exception ex)
{
//no idea why it does not work but well, log it
Trace.TraceWarning("Exception occurred during the read of message '" + sequenceNumber + "': " + ex.Message);
}
}, new OnMessageOptions {
AutoComplete = true
});
_completedEvent.WaitOne();
});
}
static async Task ReceiveAllMessageFromSubscription(string connectionString, string subsName)
{
var receivedMessages = 0;
// Create subscription client.
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, TopicName, subsName);
// Create a receiver from the subscription client and receive all messages.
Console.WriteLine("\nReceiving messages from subscription {0}.", subsName);
while (true)
{
var receivedMessage = await subscriptionClient.ReceiveAsync(TimeSpan.FromSeconds(10));
if (receivedMessage != null)
{
foreach (var prop in receivedMessage.Properties)
{
Console.Write("{0}={1},", prop.Key, prop.Value);
}
Console.WriteLine("CorrelationId={0}", receivedMessage.CorrelationId);
receivedMessages++;
}
else
{
// No more messages to receive.
break;
}
}
Console.WriteLine("Received {0} messages from subscription {1}.", receivedMessages, subsName);
}
public void Connect()
{
try
{
string ServiceBusConnectionString = String.Format(@"Endpoint=sb://{0}.servicebus.windows.net/;SharedAccessKeyName={1};SharedAccessKey={2};",
sbConfig.ServiceBusNamespace, sbConfig.SasKeyName, sbConfig.SasKey);
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(ServiceBusConnectionString);
this.subscriptionClient = SubscriptionClient.CreateFromConnectionString(ServiceBusConnectionString, sbConfig.ServiceBusTopic,
sbConfig.ServiceBusSubscription, ReceiveMode.ReceiveAndDelete);
this.subscriptionClient.OnMessage(this.OnNewMessage);
if (OnServiceBusConnected != null)
{
OnServiceBusConnected.Invoke(this.subscriptionClient.Name, this.subscriptionClient.TopicPath);
this.LogEvent(EventTypeConsts.Info, "Binding done", "Servicebus handler listining for messages.");
}
else
{
this.LogEvent(EventTypeConsts.Error, "Error", "OnServiceBusConnected handlers not set");
}
}
catch (Exception ex)
{
this.LogEvent(EventTypeConsts.Error, "subscription init error", ex.Message);
}
}
private string GetEventID()
{
string result = "";
InitTopic(); //Topicの初期化
//Subscription Clientインスタンスの作成
SClient = SubscriptionClient.
CreateFromConnectionString(connectionString,
TopicName, subscripitionname);
//Subscriptionからメッセージを受信
BrokeredMessage msg
= SClient.Receive(TimeSpan.FromSeconds(3));
if (msg != null)
{
//メッセージを取得できた場合、本文を戻り値に設定
result = msg.GetBody <string>();
msg.Complete();
}
else
{
//取得できない場合、404を返す
this.StatusCode(HttpStatusCode.NotFound);
result = "0000";
}
return(result);
}
public SubscriptionClient CreateSubscription(string subscriptionName, string roleInstanceId)
{
InitializeTopics();
// If an existing subscription is there, delete it, so we can update the filter
if (_namespaceManager.SubscriptionExists(_commandsForJobHostTopicName, subscriptionName))
{
_namespaceManager.DeleteSubscription(_commandsForJobHostTopicName, subscriptionName);
}
// Create the subscription again with the most up2date filter
var desc = new SubscriptionDescription(_commandsForJobHostTopicName, subscriptionName);
_namespaceManager.CreateSubscription
(
desc,
new SqlFilter
(
string.Format(@"{0} = '{1}'", GlobalConstants.SERVICEBUS_MESSAGE_PROP_ROLEINSTANCEID, roleInstanceId)
)
);
// Subscribe with the subscription client
var client = SubscriptionClient.CreateFromConnectionString(
_connectionString,
_commandsForJobHostTopicName,
subscriptionName);
client.RetryPolicy = RetryPolicy.Default;
return(client);
}
public string RecieveMesageFromTopic(string Subscription)
{
String messageText = string.Empty;
SubscriptionClient Client = SubscriptionClient.CreateFromConnectionString
(_connectionString, _topic, Subscription);
var message = Client.Receive();
messageText = message.GetBody <string>();
message.Complete();
// Configure the callback options.
//OnMessageOptions options = new OnMessageOptions();
//options.AutoComplete = false;
//options.AutoRenewTimeout = TimeSpan.FromMinutes(1);
//Client.OnMessage((message) =>
//{
// try
// {
// messageText = message.GetBody<string>();
// // Remove message from subscription.
// message.Complete();
// }
// catch (Exception)
// {
// // Indicates a problem, unlock message in subscription.
// message.Abandon();
// }
//}, options);
return(messageText);
}
/// <summary>
/// Constructor Methdo
/// </summary>
/// <param name="assemblyBase">type of a object from your library for to read the assembly and to find all other classes that use the Request or Notification interface informed</param>
/// <param name="connectionString">Connection string of your Azure ServiceBus</param>
/// <param name="topicName">Topic Name</param>
/// <param name="subscriptionName">Subscription Name</param>
public Subscribe(Type assemblyBase, String connectionString, String topicName, String subscriptionName)
{
this.connectionString = connectionString;
this.topicName = topicName;
this.subbscriptionName = subscriptionName;
Util.BusHelpers.InitializeSubscription(connectionString, topicName, subscriptionName);
this.subscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, topicName, subscriptionName);
Assembly assembly = assemblyBase.Assembly;
foreach (var requestTypeAddress in assembly.GetTypes().Where(filterType => filterType.GetInterfaces().Contains(typeof(IRequest))))
{
messageTypeAddresses.Add(requestTypeAddress, requestTypeAddress.Name);
}
foreach (var notificationTypeAddress in assembly.GetTypes().Where(filterType => filterType.GetInterfaces().Contains(typeof(INotification))))
{
messageTypeAddresses.Add(notificationTypeAddress, notificationTypeAddress.Name);
}
string[] rules = (from query in messageTypeAddresses select query.Value).ToArray();
AddRule(rules);
}
public Bootstrapper(TinyIoCContainer ioc)
{
_container = ioc;
_dependencyResolver = new TinyIoCDependencyResolver(_container);
// service bus
_namespaceManager = NamespaceManager.CreateFromConnectionString(ConfigurationManager.ConnectionStrings["servicebus"].ConnectionString);
_subscriptionClient = SubscriptionClient.CreateFromConnectionString(ConfigurationManager.ConnectionStrings["servicebus"].ConnectionString, "images", "nancysubscription", ReceiveMode.ReceiveAndDelete);
// storage
var storage = Microsoft.WindowsAzure.Storage.CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["storage"].ConnectionString);
// Blob
_blobClient = storage.CreateCloudBlobClient();
_blobContainer = _blobClient.GetContainerReference("images");
// Table
var tableClient = storage.CreateCloudTableClient();
_table = tableClient.GetTableReference("images");
// queue
var queueClient = storage.CreateCloudQueueClient();
_queue = queueClient.GetQueueReference("images");
}
public async Task <PollerResult <Event> > NextAsync(QueueName name)
{
try
{
BrokeredMessage message = null;
if (name.IsSimpleQueue)
{
var client = QueueClient.CreateFromConnectionString(_connectionString, name.TopicName);
message = await client.ReceiveAsync();
}
else
{
var client = SubscriptionClient.CreateFromConnectionString(_connectionString,
name.TopicName, name.SubscriptionName);
message = await client.ReceiveAsync(_longPollingTimeout);
}
return(new PollerResult <Event>(message != null,
message == null
? null
: message.ToEvent(name)
));
}
catch (Exception e)
{
Trace.TraceWarning(e.ToString());
return(new PollerResult <Event>(false, null));
}
}
public MessageReceiver(string connectionString, string topicName, string subscriptionName, string correlationFilter, int concurrentReceivers)
{
_concurrentReceivers = concurrentReceivers;
var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.TopicExists(topicName))
{
var topicDescription = new TopicDescription(topicName);
namespaceManager.CreateTopic(topicDescription);
TopicClient.CreateFromConnectionString(connectionString, topicName);
}
if (namespaceManager.SubscriptionExists(topicName, subscriptionName))
{
_subscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, topicName, subscriptionName);
}
else
{
var subscriptionDescription = new SubscriptionDescription(topicName, subscriptionName)
{
DefaultMessageTimeToLive = TimeSpan.FromDays(7),
LockDuration = TimeSpan.FromMinutes(2),
EnableDeadLetteringOnMessageExpiration = true,
EnableDeadLetteringOnFilterEvaluationExceptions = true
};
namespaceManager.CreateSubscription(subscriptionDescription, new CorrelationFilter(correlationFilter));
_subscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, topicName, subscriptionName);
}
}
private static void HandleCompanyTopic(string connectionString)
{
var clientCompany = SubscriptionClient.CreateFromConnectionString(connectionString, Constants.TopicName, Constants.Topics.Company.ToString());
var options = new OnMessageOptions {
AutoComplete = false
};
clientCompany.OnMessage((message) =>
{
try
{
// Process message from subscription.
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("\n**Company Application**");
Console.WriteLine("Body: " + message.GetBody <Applicant>());
Console.WriteLine("MessageID: " + message.MessageId);
Console.WriteLine("Application Type: " + message.Properties[Constants.CustomProperties.ApplicationType.ToString()]);
// Remove message from subscription.
message.Complete();
}
catch (Exception ex)
{
// Indicates a problem, unlock message in subscription.
Console.WriteLine(ex.Message);
message.Abandon();
}
}, options);
}
public AzureServiceBusMessageBus(string connectionString, string topicName, ISerializer serializer = null, ILoggerFactory loggerFactory = null) : base(loggerFactory)
{
_serializer = serializer ?? new JsonNetSerializer();
var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.TopicExists(topicName))
{
namespaceManager.CreateTopic(topicName);
}
_topicClient = TopicClient.CreateFromConnectionString(connectionString, topicName);
const string subscriptionName = "MessageBus";
if (!namespaceManager.SubscriptionExists(topicName, subscriptionName))
{
namespaceManager.CreateSubscription(topicName, subscriptionName);
}
_subscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, topicName, subscriptionName, ReceiveMode.ReceiveAndDelete);
_subscriptionClient.OnMessageAsync(OnMessageAsync, new OnMessageOptions {
AutoComplete = true
});
}
static void Main(string[] args)
{
if (!ArgsAreValid(args))
{
OutputProgramIntroText();
Console.WriteLine("Press Enter to exit...");
Console.ReadLine();
return;
}
string topicName = args[0];
string subscriptionName = args[1];
string connectionString = args[2];
try
{
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, topicName, subscriptionName, ReceiveMode.ReceiveAndDelete);
var options = new OnMessageOptions
{
AutoComplete = true,
MaxConcurrentCalls = 1
};
Console.WriteLine($"Listening for messages on topic '{topicName}'...");
Console.WriteLine("Press Ctrl+C to exit.");
subscriptionClient.OnMessage(ReceiveMessage, options);
Console.ReadLine();
}
catch (Exception exc)
{
Console.WriteLine($"General error. Exiting program.\n\nError Message: '{exc.Message}'\n\nStackTrace: '{exc.StackTrace}'");
}
}
public void getQueueValue(string strEndpoint, string strTopicName, string subscriptionName)
{
var connectionString = strEndpoint;
var queueName = strTopicName;
ViewBag.Endpoint = connectionString;
ViewBag.QueueName = queueName;
SubscriptionClient client = SubscriptionClient.CreateFromConnectionString(strEndpoint, strTopicName, subscriptionName);
var msg3 = "";
BrokeredMessage message = null;
NamespaceManager namespaceManager = NamespaceManager.Create();
while (true)
{
try
{
//receive messages from Queue
message = client.Receive(TimeSpan.FromSeconds(5));
ViewBag.Msg12 = "No active message is avilable in service bus queue.";
if (message != null)
{
//Console.WriteLine(string.Format("Message received: Id = {0}, Body = {1}", message.MessageId, message.GetBody<string>()));
var t = message.MessageId;
if (msg3 == "")
{
msg3 = message.GetBody <string>();
}
else
{
msg3 = msg3 + ", " + message.GetBody <string>();
}
message.Complete();
ViewBag.Msg12 = "";
// break;
}
else
{
//msg3 = "";
break;
}
}
catch (MessagingException e)
{
if (!e.IsTransient)
{
Console.WriteLine(e.Message);
throw;
}
else
{
//HandleTransientErrors(e);
}
}
}
client.Close();
ViewBag.Qmsg4 = msg3;
}
public void Constructor()
{
var name = Guid.NewGuid().ToString();
var topicPath = Guid.NewGuid().ToString();
new BusSubscriptionClient(SubscriptionClient.CreateFromConnectionString(connection, topicPath, name));
}
public void Init()
{
var connectionString = ConfigurationManager.AppSettings["ServiceBus.ConnectionString"];
var topicPath = ConfigurationManager.AppSettings["TopicName"];
var subscriptionName = "UnitTest";
var topicDescription = new TopicDescription(topicPath)
{
MaxSizeInMegabytes = 1024,
DefaultMessageTimeToLive = new TimeSpan(0, 1, 0)
};
var timeProvider = new UtcTimeProvider();
var logger = new Mock <ILogger>();
_evtPublisher = new EventTopicPublisher(connectionString, topicDescription, timeProvider, logger.Object);
var namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!namespaceManager.SubscriptionExists(topicPath, subscriptionName))
{
namespaceManager.CreateSubscription(topicPath, subscriptionName);
}
_client = SubscriptionClient.CreateFromConnectionString(connectionString, topicPath, subscriptionName);
}
private AssetsEventsService(IHubConnectionContext <dynamic> clients)
{
System.Diagnostics.Trace.TraceInformation("AssetsEventsService: initialize");
Clients = clients;
initializeDeskInfoCol();
string connectionString = ConfigurationManager.ConnectionStrings["Microsoft.ServiceBus.ConnectionString"].ConnectionString;
string topic = ConfigurationManager.AppSettings["Microsoft.ServiceBus.Topic"];
string subscription = ConfigurationManager.AppSettings["Microsoft.ServiceBus.Subscription"];
_serviceBusClient = SubscriptionClient.CreateFromConnectionString(connectionString, topic, subscription, ReceiveMode.ReceiveAndDelete);
_serviceBusClient.OnMessage((message) =>
{
try
{
// Process message from subscription.
var assetsFromServiceBus = JsonConvert.DeserializeObject <AssetServiceBus>(message.GetBody <string>());
updateAssetState(assetsFromServiceBus.logicalName, assetsFromServiceBus.state, assetsFromServiceBus.time);
}
catch (Exception)
{
// Indicates a problem, unlock message in subscription.
System.Diagnostics.Trace.TraceError("AssetsEventsService: can't read message from topic");
}
});
}
/// <summary>
/// Creates <see cref="AzureBus{TAuthenticationToken}.NumberOfReceiversCount"/> <see cref="SubscriptionClient"/>.
/// If flushing is required, any flushed <see cref="SubscriptionClient"/> has <see cref="ClientEntity.Close()"/> called on it first.
/// </summary>
/// <param name="namespaceManager">The <see cref="NamespaceManager"/>.</param>
/// <param name="serviceBusReceivers">The receivers collection to place <see cref="SubscriptionClient"/> instances into.</param>
/// <param name="topicName">The topic name.</param>
/// <param name="topicSubscriptionName">The topic subscription name.</param>
protected virtual void InstantiateReceiving(NamespaceManager namespaceManager, IDictionary <int, SubscriptionClient> serviceBusReceivers, string topicName, string topicSubscriptionName)
{
for (int i = 0; i < NumberOfReceiversCount; i++)
{
SubscriptionClient serviceBusReceiver = SubscriptionClient.CreateFromConnectionString(ConnectionString, topicName, topicSubscriptionName);
if (serviceBusReceivers.ContainsKey(i))
{
serviceBusReceivers[i] = serviceBusReceiver;
}
else
{
serviceBusReceivers.Add(i, serviceBusReceiver);
}
}
// Remove any if the number has decreased
for (int i = NumberOfReceiversCount; i < serviceBusReceivers.Count; i++)
{
SubscriptionClient serviceBusReceiver;
if (serviceBusReceivers.TryGetValue(i, out serviceBusReceiver))
{
serviceBusReceiver.Close();
}
serviceBusReceivers.Remove(i);
}
}
public PushNotification()
{
var subscriptionName = Guid.NewGuid().ToString();
var namespaceMgr = NamespaceManager.CreateFromConnectionString(ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"]);
var subscriptionDescription = new SubscriptionDescription(ConfigurationManager.AppSettings["Microsoft.ServiceBus.Topic.Name"], subscriptionName)
{
AutoDeleteOnIdle = TimeSpan.FromMinutes(5)
};
namespaceMgr.CreateSubscription(subscriptionDescription);
subscriptionClient = SubscriptionClient.CreateFromConnectionString(
ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"],
ConfigurationManager.AppSettings["Microsoft.ServiceBus.Topic.Name"],
subscriptionName);
var onMessageOptions = new OnMessageOptions()
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
subscriptionClient.OnMessage(message => ProcessMessage(message), onMessageOptions);
}
private void StartSubscriptionClient()
{
string connectionString = CloudConfigurationManager.GetSetting("SInnovations.Servicebus.ConnectionString");
var namespaceManager =
NamespaceManager.CreateFromConnectionString(connectionString);
TopicDescription td = new TopicDescription(TopicName);
td.MaxSizeInMegabytes = 512;
td.DefaultMessageTimeToLive = new TimeSpan(0, 5, 0);
if (!namespaceManager.TopicExists(TopicName))
{
namespaceManager.CreateTopic(td);
}
if (!namespaceManager.SubscriptionExists(TopicName, AllMessages))
{
namespaceManager.CreateSubscription(TopicName, AllMessages);
}
Client = SubscriptionClient.CreateFromConnectionString
(connectionString, TopicName, AllMessages);
var options = new OnMessageOptions {
AutoComplete = false, MaxConcurrentCalls = 10
};
options.ExceptionReceived += options_ExceptionReceived;
Client.OnMessageAsync(OnMessageAsync, options);
CompletedEvent.WaitOne();
}
public AzureServiceBusMessageQueue(string connectionString, string inputQueue)
{
log.Info("Initializing Azure Service Bus transport with logical input queue '{0}'", inputQueue);
namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
InputQueue = inputQueue;
log.Info("Ensuring that topic '{0}' exists", TopicName);
if (!namespaceManager.TopicExists(TopicName))
{
try
{
namespaceManager.CreateTopic(TopicName);
}
catch
{
// just assume the call failed because the topic already exists - if GetTopic below
// fails, then something must be wrong, and then we just want to fail immediately
}
}
topicDescription = namespaceManager.GetTopic(TopicName);
GetOrCreateSubscription(InputQueue);
log.Info("Creating topic client");
topicClient = TopicClient.CreateFromConnectionString(connectionString, topicDescription.Path);
log.Info("Creating subscription client");
subscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, TopicName, InputQueue);
}
public void Start()
{
Trace.TraceInformation("Start");
// A new subscription client is created on start and which closed
// on close.
try {
if (ingressTopicSubscription == null || ingressTopicSubscription.IsClosed)
{
var connectionString
= ConfigurationManager.AppSettings["ingress_gateway_service_bus_connection_string"];
ingressTopicSubscription
= SubscriptionClient.CreateFromConnectionString(
connectionString
, TopicSourceName
, TopicSubscriptionName
);
ingressTopicSubscription.OnMessage(handleMessage);
Trace.TraceInformation($"{ this.GetType().Name } - Listening for messages");
}
} catch (Exception e) {
Trace.TraceError($"{ this.GetType().Name } - Message: { e.Message }, Stack trace: { e.StackTrace }");
throw;
}
}
public static void DoWork(bool SB)
{
System.Threading.ThreadPool.SetMaxThreads(10, 10);
var connectionString = "Endpoint=sb://servicebus-namespace-2.servicebus.windows.net/;SharedAccessKeyName=servicebus-env-002-servicebus-namespace-2-pankil;SharedAccessKey=856mIAhotFSpkSXA0uts2uXmn4Ud87k9w21Vb5ZsBew=";
var topicName = "main-topic-env-002-servicebus-namespace-2";
var subscriptionName = "AllocationOrchestration_Pankil/$DeadLetterQueue";
SubscriptionClient subscriptionClient = null;
//int i = 0;
while (true)
{
try
{
OnMessageOptions options = new OnMessageOptions();
options.AutoComplete = false;
options.MaxConcurrentCalls = 10;
subscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, topicName, subscriptionName, ReceiveMode.PeekLock);
subscriptionClient.OnMessage(msg =>
{
Console.WriteLine(string.Format("{0}: Thread Started: {1}", DateTime.Now.ToString("dd-MM-yyyy HH:mm:ss.fff"), msg.CorrelationId));
System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(AnotherLongTask), msg);
}, options);
}
catch (Exception ex)
{
//Log Error
}
finally
{
subscriptionClient = null;
}
}
}
