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 bool SendMessage(BrokeredMessage message)
{
int trycount = 0;
bool success = false;
while (trycount++ < 10)
{
try
{
topic.Send(message);
success = true;
break;
}
catch
{
MessagingFactory factory = MessagingFactory.Create(uri, tP);
topic = factory.CreateMessageSender(hubmessagingtopic);
}
}
message.Dispose();
if (success)
{
return(true);
}
else
{
return(false);
}
}
static void SendMessage()
{
TokenProvider tokenProvider = _namespaceManager.Settings.TokenProvider;
if (!_namespaceManager.TopicExists("DataCollectionTopic"))
{
_namespaceManager.CreateTopic("DataCollectionTopic");
if (!_namespaceManager.SubscriptionExists("DataCollectionTopic", "Inventory"))
{
_namespaceManager.CreateSubscription("DataCollectionTopic", "Inventory");
}
if (!_namespaceManager.SubscriptionExists("DataCollectionTopic", "Dashboard"))
{
_namespaceManager.CreateSubscription("DataCollectionTopic", "Dashboard");
}
MessagingFactory factory = MessagingFactory.Create(_namespaceManager.Address, tokenProvider);
BrokeredMessage message = new BrokeredMessage();//can pass a user defined class too
message.Label = "SalesReport";
message.Properties["StoreName"] = "Nike";
message.Properties["MachineID"] = "POS1";
BrokeredMessage message1 = new BrokeredMessage();//can pass a user defined class too
message1.Label = "SalesRep";
message1.Properties["StoreName"] = "Addidas";
message1.Properties["MachineID"] = "POS3";
MessageSender sender = factory.CreateMessageSender("DataCollectionTopic");
sender.Send(message);
sender.Send(message1);
Console.WriteLine("Message Sent Succefully");
}
}
public void PushRecords(IEnumerable <DatasourceRecord> records)
{
//TODO: determine how the queues will be named
var sender = _factory.CreateMessageSender(_config.ReceiverQueue.QueueName);
var recList = records.ToList(); //avoid reenumerations
using (var ms = _recordSerializer.Serialize(recList))
{
string hashString;
using (var hasher = MurmurHash.Create128())
{
var hash = hasher.ComputeHash(ms);
hashString = Encoding.UTF8.GetString(hash);
}
ms.Position = 0;
var msg = new BrokeredMessage(ms, false)
{
MessageId = hashString
};
var sw = new Stopwatch();
sw.Start();
sender.Send(msg);
sw.Stop();
Log.DebugFormat("Pushed {0} records to topic/queue in {1}ms", recList.Count, sw.ElapsedMilliseconds);
}
}
public async Task SendMessages()
{
List <Task> tasks = new List <Task>();
messageSender = factory.CreateMessageSender(queuename);
stopwatch.Start();
for (int i = 0; i < numberOfMessages; i++)
{
tasks.Add(Task.Factory.StartNew(MessageToBeSend));
}
Task.WaitAll(tasks.ToArray());
stopwatch.Stop();
var elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
Console.WriteLine("Sent {0} messages in {1} ms", numberOfMessages, elapsedMilliseconds);
Console.WriteLine("{0} per second", elapsedMilliseconds == 0 ? 0L : (1000 * numberOfMessages) / elapsedMilliseconds);
Console.WriteLine("Sleeping for 10 seconds before receiving...");
Thread.Sleep(20000);
}
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++;
}
}
}
}
private static MessageSender InitMessageSender()
{
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(ServiceBusConnectionString);
factory.RetryPolicy = RetryPolicy.Default;
return(factory.CreateMessageSender(ServiceBusQueueName));
}
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();
}
private void Scenario11_QueueReceiver(object obj)
{
string queue = (string)obj;
ServiceBusConnectionStringBuilder builder = new ServiceBusConnectionStringBuilder(this.ConnectionString);
builder.TransportType = TransportType.Amqp;
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(this.ConnectionString);
QueueClient client = factory.CreateQueueClient(queue);
while (true)
{
BrokeredMessage request = client.Receive();
request.Complete();
MessageSender sender = factory.CreateMessageSender(request.ReplyTo);
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes("Response"));
BrokeredMessage response = new BrokeredMessage(stream);
response.CorrelationId = request.MessageId;
response.Properties["time"] = DateTime.UtcNow;
sender.Send(response);
sender.Close();
}
}
private void btnQueue_Click(object sender, EventArgs e)
{
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);
MessagingFactory factory = MessagingFactory.Create(uri, tokenProvider);
var msg = new ServiceBusTestMessage
{
Password = tbPass.Text
};
BrokeredMessage sbMessage = new BrokeredMessage(msg);
sbMessage.Label = "test message";
sbMessage.Properties["login"] = tbLogin.Text;
MessageSender messageSender = factory.CreateMessageSender("MyTopic");
messageSender.Send(sbMessage);
}
public void RequeueOne(string queuePath, string messageId, string newBody)
{
var client = _messagingFactory.CreateQueueClient(queuePath);
var queue = _namespaceManager.GetQueue(queuePath.RemoveDeadLetterPath());
var count = GetQueueMessageCount(queuePath, queue);
var sender = _messagingFactory.CreateMessageSender(queuePath.RemoveDeadLetterPath());
var msgs = client.ReceiveBatch(Convert.ToInt32(count));
foreach (var msg in msgs)
{
if (msg.MessageId != messageId)
{
msg.Abandon();
continue;
}
var clone = Clone(msg, newBody);
clone.RemoveProperties(GetPropertiesToRemove());
if (clone.Properties.ContainsKey("RequeuedFrom"))
{
clone.Properties["RequeuedFrom"] = clone.Properties["RequeuedFrom"] += "," + msg.MessageId;
}
else
{
clone.Properties.Add("RequeuedFrom", msg.MessageId);
}
msg.Complete();
sender.Send(clone);
}
}
public ActionResult Save(ShareUpdateForm shareUpdateForm)
{
// If model is not valid just redirect it back
if (!ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
// Saving the data from the form
Guid postId;
using (var db = new AzureChallengeContext())
{
var userPost = new Userpost
{
Text = shareUpdateForm.Message,
CreationDateTime = DateTime.Now
};
db.Userposts.Add(userPost);
db.SaveChanges();
postId = userPost.Id;
}
if (shareUpdateForm.Image != null)
{
var imageId = Guid.NewGuid();
string imageFilename = $"{imageId}_{shareUpdateForm.Image.FileName}";
// Create the table entity
var imagePost = new ImagePost(postId.ToString(), imageId.ToString())
{
Filename = imageFilename
};
// Save the Image to a Blob
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(_storageConnectionString);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference("images");
CloudBlockBlob blockBlob = container.GetBlockBlobReference(imageFilename);
blockBlob.UploadFromStream(shareUpdateForm.Image.InputStream);
// Save the result in a Azure Table
CloudTableClient tableClient = storageAccount.CreateCloudTableClient();
CloudTable table = tableClient.GetTableReference("images");
table.CreateIfNotExists();
TableOperation insertOperation = TableOperation.Insert(imagePost);
TableResult result = table.Execute(insertOperation);
// Add message to Service Bus Topic
MessagingFactory messagingFactory = MessagingFactory.CreateFromConnectionString(_serviceBusConnectionString);
MessageSender messageSender = messagingFactory.CreateMessageSender("social");
messageSender.Send(new BrokeredMessage($"{postId}|{imageId}"));
}
return(RedirectToAction("Index"));
}
public void SendWithDelay(Message message, int delayMilliseconds = 0)
{
logger.DebugFormat("AzureServiceBusMessageProducer: Publishing message to namespace {0}", this.configuration.Namespace);
var messageSender = factory.CreateMessageSender(message.Header.Topic);
messageSender.Send(new BrokeredMessage(message));
logger.DebugFormat("AzureServiceBusMessageProducer: Published message to namespace {0}", this.configuration.Namespace);
}
public void SendMesage(string message)
{
CreateQueue(_queue);
MessageSender testSender = _factory.CreateMessageSender(_queue);
BrokeredMessage brokeredMessage = new BrokeredMessage(message);
testSender.Send(brokeredMessage);
//testSender.Close();
}
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();
}
public MessageSender GetMessageSender(string path)
{
if (senders.ContainsKey(path))
{
return(senders[path]);
}
var sender = factory.CreateMessageSender(path);
senders.TryAdd(path, sender);
return(sender);
}
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));
}
private void TransactionQueueSend(string TransactionID,
decimal Amount,
string EmailAddress,
string CustomerProfileID,
int AAVend,
int AAAVend,
int AAReturn,
int AAAReturn,
string Authorization)
{
// Sends a Transaction Message to the Service Bus
string ConnectionString = Application.Current.Properties["serviceBusconnectionString"].ToString();
// Configure Queue Settings
QueueDescription qd = new QueueDescription("TransactionQueue");
qd.MaxSizeInMegabytes = 5120;
qd.DefaultMessageTimeToLive = new TimeSpan(0, 1, 0);
// Create a new Queue with custom settings
var namespaceManager = NamespaceManager.CreateFromConnectionString(ConnectionString);
if (!namespaceManager.QueueExists("TransactionQueue"))
{
namespaceManager.CreateQueue("TransactionQueue");
}
// Send a message
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(ConnectionString);
MessageSender sender = factory.CreateMessageSender("TransactionQueue");
// Create message, passing a string message for the body
BrokeredMessage message = new BrokeredMessage("Kiosk Transaction");
// Set some additional custom app-specific properties
message.Properties["OrderNumber"] = _orderNumber;
message.Properties["Amount"] = Amount;
message.Properties["EmailAddress"] = EmailAddress;
message.Properties["CustomerProfileID"] = CustomerProfileID;
message.Properties["AAVend"] = AAVend;
message.Properties["AAAVend"] = AAAVend;
message.Properties["AAReturn"] = AAReturn;
message.Properties["AAAReturn"] = AAAReturn;
message.Properties["Authorization"] = Authorization;
// Send message to the queue
sender.Send(message);
}
private async Task EnsureSend(BrokeredMessage message, string path)
{
Trace();
while (true)
{
try
{
//first check if sender exists but for a different destination
if (_sender != null && !_sender.Path.Equals(path))
{
try
{
_sender.Close();
}
catch (Exception e)
{
Error(e.ToString(), nameof(EnsureSend));
_sender.Abort();
Info("Called sender abort", nameof(EnsureSend));
}
finally
{
_sender = null;
}
}
//second check if sender is null or closed
if (_sender == null || _sender.IsClosed)
{
Trace("Creating sender", nameof(EnsureSend));
_sender = MessagingFactory.CreateMessageSender(path);
}
Trace("Trying to send now");
//try to send the message and break from the endless loop
await _sender.SendAsync(message);
break;
}
catch (Exception e)
{
//kill the messenger if it acted up.
Error($"There was an exception while trying to send a message: {e.ToString()}");
_sender.Abort();
Info("Called sender abort", nameof(EnsureSend));
_sender = null;
}
}
}
public Bus() {
connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");
namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
// Configure Topic Settings
var td = new TopicDescription(topicName);
td.MaxSizeInMegabytes = 5120;
td.DefaultMessageTimeToLive = new TimeSpan(0, 1, 0);
if (!namespaceManager.TopicExists(topicName)) {
namespaceManager.CreateTopic(topicName);
}
factory = MessagingFactory.CreateFromConnectionString(connectionString);
sender = factory.CreateMessageSender(topicName);
}
public Task SendAsync(T message, string topicName)
{
var sender = _messagingFactory.CreateMessageSender(topicName);
var body =
JsonConvert.SerializeObject(
new { Data = message },
Formatting.None,
new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}
);
var bytes = Encoding.UTF8.GetBytes(body);
var stream = new MemoryStream(bytes, writable: false);
var brokeredMessage = new BrokeredMessage(stream)
{
ContentType = "application/json"
};
if (message is IHasCorrelationId correlationMessage)
{
brokeredMessage.CorrelationId = correlationMessage.CorrelationId ?? brokeredMessage.CorrelationId;
}
_azureTopicMqSettings.AzureMessagePropertyBuilder(message)
.ToList()
.ForEach(x => brokeredMessage.Properties.Add(x.Key, x.Value));
if (!_excludeTopicsFromLogging.Contains(topicName))
{
_logMessage($"{nameof(SendAsync)}/{topicName} sending message '{body}' with Azure MessageId: '{brokeredMessage.MessageId}'");
}
return(sender.SendAsync(brokeredMessage)
.ContinueWith(task =>
{
if (task.Exception != null)
{
_logError($"{nameof(SendAsync)}/{topicName} error occurred: {task.Exception}");
}
return task;
}));
}
protected static void AzureMessageSender(MessagingFactory f)
{
//use the already created messaging factory to create a msg sender
MessageSender testQueueSender = f.CreateMessageSender(databaseName);
SqlConnection conn = new SqlConnection(databaseConnection);
try
{
conn.Open();
SqlCommand cmd = new SqlCommand(execSendQuery, conn);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
//parameters
cmd.Parameters.Add("@r", SqlDbType.NVarChar, 50).Direction = ParameterDirection.Output;
cmd.ExecuteNonQuery();
//read output
string result = Convert.ToString(cmd.Parameters["@r"].Value);
//craft and send message
BrokeredMessage message = new BrokeredMessage(result);
testQueueSender.Send(message);
Console.WriteLine("Message is sent: " + result);
cmd.Dispose();
}
catch (Exception o)
{
Console.WriteLine(o);
}
finally
{
if (conn != null)
{ conn.Close(); }
}
}
public MessageBroker(int messageTopicNumber)
{
hubmessagingtopic = "skillcow"; // RoleEnvironment.GetConfigurationSettingValue("servicebustopic" + messageTopicNumber);
//Send a message to WireUp the hub
tP = TokenProvider.CreateSharedSecretTokenProvider(issuer, key);
// Retrieve URI of our service namespace (created via the portal)
uri = ServiceBusEnvironment.CreateServiceUri("sb", "chaindateservicebus", string.Empty);
while (true)
{
try
{
// Create NamespaceManager for our service namespace
NamespaceManager namespaceManager = new NamespaceManager(uri, tP);
if (!namespaceManager.TopicExists(hubmessagingtopic))
{
// Configure Topic Settings
TopicDescription td = new TopicDescription(hubmessagingtopic);
td.MaxSizeInMegabytes = 1024;
td.DefaultMessageTimeToLive = new TimeSpan(0, 5, 0);
// Create a new Topic with custom settings
namespaceManager.CreateTopic(td);
}
MessagingFactory factory = MessagingFactory.Create(uri, tP);
topic = factory.CreateMessageSender(hubmessagingtopic);
break;
}
catch
{
}
}
MessageTopicNumber = messageTopicNumber;
}
public async Task SendMessages()
{
messageSender = factory.CreateMessageSender(queuename);
stopwatch.Start();
for (int i = 0; i < numberOfMessages; i++)
{
string message = _loader.GetClaim();
await messageSender.SendAsync(new BrokeredMessage(message));
}
stopwatch.Stop();
var elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
Console.WriteLine("Sent {0} messages in {1} ms", numberOfMessages, elapsedMilliseconds);
Console.WriteLine("{0} per second", elapsedMilliseconds == 0 ? 0L : (1000 * numberOfMessages) / elapsedMilliseconds);
Console.WriteLine("Sleeping for 10 seconds before receiving...");
Thread.Sleep(20000);
}
public Task SendAsync(T message, string queueName)
{
var sender = _messagingFactory.CreateMessageSender(queueName);
var body =
JsonConvert.SerializeObject(
new { Data = message },
Formatting.None,
new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}
);
if (!_excludeQueuesFromLogging.Contains(_queueName))
{
_logMessage($"{nameof(SendAsync)}/{_queueName} sending message '{body}'");
}
var bytes = Encoding.UTF8.GetBytes(body);
var stream = new MemoryStream(bytes, writable: false);
return(sender.SendAsync(new BrokeredMessage(stream)
{
ContentType = "application/json"
})
.ContinueWith(task =>
{
if (task.Exception != null)
{
_logError($"{nameof(SendAsync)}/{_queueName} error occurred: {task.Exception}");
}
return task;
}));
}
private static async Task <SendResult> DoQueueSendOperation(string connectionString, string path, TimeSpan timeout, bool useCached, Func <MessageSender, Task <SendResult> > operation)
{
MessagingFactory mfactory = null;
MessageSender requestClient = null;
try
{
if (useCached)
{
requestClient = ServiceBusMessagingFactory.Instance.GetMessageSender(connectionString, path, timeout);
}
else
{
mfactory = ServiceBusMessagingFactory.CreateMessagingFactoryWithTimeout(connectionString, timeout);
requestClient = mfactory.CreateMessageSender(path);
}
return(await operation.Invoke(requestClient).ConfigureAwait(false));
}
finally
{
requestClient?.Close();
mfactory?.Close();
}
}
/// <summary>
/// Initialize
/// </summary>
public void Initialize(string azureServerConnectionString)
{
//AzureMessageClient = PinkoConfiguration.QueueConfiguration[QueueName].Item2
// ? (MessageClientEntity)QueueClient.CreateFromConnectionString(azureServerConnectionString, QueueName)
// : (MessageClientEntity)TopicClient.CreateFromConnectionString(azureServerConnectionString, QueueName);
//IsTopic = AzureMessageClient is TopicClient;
// Internal memory message bus
_messageHandlerManager = PinkoContainer.Resolve<MessageHandlerManager>().Initialize();
// Azure msg factory
var tokenProvider = TokenProvider.CreateSharedSecretTokenProvider("pinko-app-bus", "S6c6FYYpdWvOLscjmUyJWQDiQd01gxENzm+W/FSjOk4=");
_messageFactory = MessagingFactory.Create(AzureNamespaceManager.Address, tokenProvider);
_msgSender = _messageFactory.CreateMessageSender(QueueName);
// http://msdn.microsoft.com/en-us/library/windowsazure/hh699844.aspx
// http://msdn.microsoft.com/en-us/library/windowsazure/microsoft.servicebus.messaging.messagingfactory.aspx
//_azureNamespaceManager.CreateSubscription(queueName,"PinkoTopic");
//_azureNamespaceManager.crea
//MessageReceiver receiver = .CreateMessageReceiver("DataCollectionTopic/subscriptions/Inventory");
//BrokeredMessage receivedMessage = receiver.Receive();
//try
//{
// ProcessMessage(receivedMessage);
// receivedMessage.Complete();
//}
//catch (Exception e)
//{
// receivedMessage.Abandon();
//}
//Similar to using queues, the simplest way to receive messages from a subscription is to use a MessageReceiver object which you can create directly from the MessagingFactory using CreateMessageReceiver. You can use one of the two different receive modes (ReceiveAndDelete and PeekLock), as discussed in Creating Applications that Use Service Bus Queues.
//Note that when you create a MessageReceiver for subscriptions, the entityPath parameter is of the form topicPath/subscriptions/subscriptionName. Therefore, to create a MessageReceiver for the Inventory subscription of the DataCollectionTopic topic, entityPath must be DataCollectionTopic/subscriptions/Inventory. The code appears as follows:
}
async Task RunEnd2EndSerializerTests(TransportType transportType, string sbConnectionString)
{
string queueName = TestConstants.NonPartitionedQueueName;
// Create a full framework MessageSender
MessagingFactory messagingFactory = MessagingFactory.CreateFromConnectionString(sbConnectionString);
MessageSender fullFrameWorkClientSender = messagingFactory.CreateMessageSender(queueName);
// Create a .NetStandard MessageReceiver
Core.MessageReceiver dotNetStandardMessageReceiver = new Core.MessageReceiver(TestUtility.NamespaceConnectionString, queueName, ServiceBus.ReceiveMode.ReceiveAndDelete);
try
{
// Send Plain string
string message1Body = "contosoString";
var message1 = new BrokeredMessage(message1Body);
await fullFrameWorkClientSender.SendAsync(message1);
// Receive Plain string
var returnedMessage = await dotNetStandardMessageReceiver.ReceiveAsync();
TestUtility.Log($"Message1 SequenceNumber: {returnedMessage.SystemProperties.SequenceNumber}");
var returnedBody1 = returnedMessage.GetBody <string>();
TestUtility.Log($"Message1: {returnedBody1}");
Assert.True(string.Equals(message1Body, returnedBody1));
// Send Custom object
var book = new TestBook("contosoBook", 1, 5);
var message2 = new BrokeredMessage(book);
await fullFrameWorkClientSender.SendAsync(message2);
// Receive Custom object
returnedMessage = await dotNetStandardMessageReceiver.ReceiveAsync();
TestUtility.Log($"Message2 SequenceNumber: {returnedMessage.SystemProperties.SequenceNumber}");
var returnedBody2 = returnedMessage.GetBody <TestBook>();
TestUtility.Log($"Message2: {returnedBody2}");
Assert.Equal(book, returnedBody2);
// Send UTF8 encoded byte array object
string message3Body = "contosoBytes";
var message3 = new BrokeredMessage(Encoding.UTF8.GetBytes(message3Body));
await fullFrameWorkClientSender.SendAsync(message3);
// Receive UTF8 encoded byte array object
returnedMessage = await dotNetStandardMessageReceiver.ReceiveAsync();
TestUtility.Log($"Message3 SequenceNumber: {returnedMessage.SystemProperties.SequenceNumber}");
var returnedBody3 = Encoding.UTF8.GetString(returnedMessage.GetBody <byte[]>());
TestUtility.Log($"Message1: {returnedBody3}");
Assert.True(string.Equals(message3Body, returnedBody3));
// Send Stream Object
string message4Body = "contosoStreamObject";
var message4 = new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(message4Body)));
await fullFrameWorkClientSender.SendAsync(message4);
// Receive Stream Object
returnedMessage = await dotNetStandardMessageReceiver.ReceiveAsync();
TestUtility.Log($"Message3 SequenceNumber: {returnedMessage.SystemProperties.SequenceNumber}");
var returnedBody4 = Encoding.UTF8.GetString(returnedMessage.Body);
TestUtility.Log($"Message4: {returnedBody4}");
Assert.True(string.Equals(message4Body, returnedBody4));
}
finally
{
await dotNetStandardMessageReceiver.CloseAsync();
await fullFrameWorkClientSender.CloseAsync();
}
}
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();
}
}
protected override void OnStart()
{
workerQueueClient = messagingFactory.CreateQueueClient(workerQueueName);
deciderSender = messagingFactory.CreateMessageSender(orchestratorQueueName, workerQueueName);
}
public void SetUp()
{
factory = MessagingFactory.CreateFromConnectionString(ConfigurationManager.ConnectionStrings["StockEventServiceBus"].ToString());
sender = factory.CreateMessageSender("stocklevels");
}
public static MessageSender CreateMessageSender(MessagingFactory senderFactory, string transferDestinationEntityPath, string viaEntityPath)
{
return(senderFactory.CreateMessageSender(transferDestinationEntityPath, viaEntityPath));
}
public static MessageSender CreateMessageSender(MessagingFactory senderFactory, string entityPath)
{
return(senderFactory.CreateMessageSender(entityPath));
}
public IMessagingSender CreateMessageSender(string id)
{
return(new ServiceBusSender(_implementation.CreateMessageSender(id)));
}
