static async void processSub()
{
while (true)
{
var msg = await m_clientSub.ReceiveAsync();
if (msg != null)
{
Console.WriteLine($"SUB: {msg.MessageId}");
if (msg.DeliveryCount > 1)
{
Param p = msg.GetBody <Param>();
Console.WriteLine($"SUB: {msg.MessageId}, {DateTime.Now.Ticks}: {p.A}, {p.B}");
BrokeredMessage msgResp = new BrokeredMessage(p.A - p.B);
msgResp.SessionId = msg.ReplyToSessionId;
await m_queue.SendAsync(msgResp);
await m_clientSub.CompleteAsync(msg.LockToken);
}
else
{
Console.WriteLine($"SUB: {msg.MessageId}, Exception, bad processing - {msg.DeliveryCount}");
}
}
}
}
private async Task RunAsync()
{
Debug.WriteLine("Bus listener started");
while (!_cancellationTokenSource.IsCancellationRequested)
{
try
{
var m = await _subscriptionClient.ReceiveAsync(TimeSpan.FromSeconds(5));
if (m != null)
{
InformClientsOfNewImage();
}
else
{
PingClients();
}
}
catch (Exception e)
{
Debug.WriteLine("Error receiving message from subscription " + e.ToString());
}
}
Debug.WriteLine("Bus listener stopped");
}
private async void waitForMessage()
{
while (true)
{
m_msg = await m_clientAll.ReceiveAsync();
if (m_msg != null)
{
await this.Dispatcher.InvokeAsync(async() =>
{
string deviceId = m_msg.Properties["iothub-connection-device-id"]?.ToString();
var deviceTwin = await m_rm.GetTwinAsync(deviceId);
StringBuilder sb = new StringBuilder();
sb.AppendLine(deviceTwin.Tags["address"].ToString());
sb.AppendLine(deviceTwin.Tags["city"].ToString());
sb.AppendLine(deviceTwin.Tags["country"].ToString());
sb.AppendLine(deviceTwin.Tags["notes"].ToString());
txtInfo.Text = sb.ToString();
btnConfirm.IsEnabled = true;
});
return;
}
}
}
public async Task <IMessage <T> > ReceiveAsAsync()
{
while (true)
{
return(await _executionPolicy.ExecuteAsync(async() =>
{
try
{
if (!_clientOpen)
{
OpenClient();
}
BrokeredMessage brokeredMessage;
IMessage <T> message;
do
{
brokeredMessage = await _client.ReceiveAsync();
message = await DeserialiseAzureBrokeredMessage(brokeredMessage);
} while (brokeredMessage != null && message == null);
return message;
}
catch (SessionLockLostException)
{
RefreshClient();
throw;
}
}));
}
}
public static IObservable<IBusMessage<T>> CreateObervable<T>(this SubscriptionClient client, CancellationToken cancellationToken)
{
Func<IObserver<ServiceBusBusMessage<T>>, Task> t = async (observer) =>
{
try
{
while (!client.IsClosed)
{
cancellationToken.ThrowIfCancellationRequested();
var message = await client.ReceiveAsync(serverWaitTime: TimeSpan.FromSeconds(10));
if (message == null)
{
continue;
}
var body = new ServiceBusBusMessage<T>(message);
observer.OnNext(body);
}
observer.OnCompleted();
}
catch (Exception e)
{
observer.OnError(e);
}
};
return Observable
.Create<ServiceBusBusMessage<T>>(t)
.Publish()
.RefCount();
}
public async Task <CommandMessage> ReceiveCommandAsync(TimeSpan waitTime)
{
BrokeredMessage bm = null;
CommandMessage commandMessage = null;
AssertThingsAccess();
using (bm = await _messagingPolicy.ExecuteAsync(() => _subscriptionClient.ReceiveAsync(waitTime)))
{
try
{
if (bm != null)
{
commandMessage = bm.GetBody <CommandMessage>();
await _messagingPolicy.ExecuteAsync(() => bm.CompleteAsync());
}
}
catch
{
_messagingPolicy.Execute(() => { bm.Abandon(); });
}
}
return(commandMessage);
}
private async Task RunAsync(CancellationToken cancellationToken)
{
SubscriptionClient client = GetOrRenewClient();
while (!cancellationToken.IsCancellationRequested)
{
try
{
var message = await client.ReceiveAsync(TimeSpan.FromSeconds(15));
if (message != null)
{
await ProvisionSite(message.GetBody <ProvisionRequest>());
}
}
catch (TimeoutException)
{
Trace.TraceInformation("Connection timeout");
}
catch (Exception ex)
{
LogException(ex);
client = GetOrRenewClient();
}
await Task.Delay(1000);
}
}
private void Run1(CancellationToken cancellationToken)
{
List <Task> lst = new List <Task>();
lst.Add(Task.Factory.StartNew(async() =>
{
while (!cancellationToken.IsCancellationRequested)
{
var msg = await m_clientSuma.ReceiveAsync(TimeSpan.FromSeconds(60));
if (msg != null)
{
var arr = msg.GetBody <byte[]>();
var msgResp = new BrokeredMessage(string.Format(" Suma elementów: " + arr.Sum(a => a)));
msgResp.SessionId = msg.ReplyToSessionId;
await m_queue.SendAsync(msgResp);
Trace.TraceInformation("wSuma,Task: MessageId:{0}", msg.MessageId);
await msg.CompleteAsync();
}
}
}, cancellationToken)
);
lst.Add(Task.Factory.StartNew(async() =>
{
while (!cancellationToken.IsCancellationRequested)
{
var msg = await m_clientSrednia.ReceiveAsync(TimeSpan.FromSeconds(60));
if (msg != null)
{
var arr = msg.GetBody <byte[]>();
var msgResp = new BrokeredMessage(string.Format(" Średnia z elementów: " + arr.Average(a => a)));
msgResp.SessionId = msg.ReplyToSessionId;
await m_queue.SendAsync(msgResp);
Trace.TraceInformation("wSrednia,Task: MessageId:{0}", msg.MessageId);
await msg.CompleteAsync();
}
}
}, cancellationToken)
);
lst.Add(Task.Factory.StartNew(async() =>
{
while (!cancellationToken.IsCancellationRequested)
{
var msg = await m_clientLiczba.ReceiveAsync(TimeSpan.FromSeconds(60));
if (msg != null)
{
var arr = msg.GetBody <byte[]>();
var msgResp = new BrokeredMessage(string.Format(" Liczba elementów: " + arr.Length));
msgResp.SessionId = msg.ReplyToSessionId;
await m_queue.SendAsync(msgResp);
Trace.TraceInformation("wLiczba,Task: MessageId:{0}", msg.MessageId);
await msg.CompleteAsync();
}
}
}, cancellationToken)
);
Task.WaitAll(lst.ToArray(), cancellationToken);
}
public async Task <IMessageContext <T> > ReceiveAsync()
{
var message = await SubscriptionClient.ReceiveAsync();
if (message == null)
{
return(null);
}
return(new AzureBrokeredMessageContext <T>(message, message.GetBody <T>()));
}
public async Task Start()
{
SubscriptionClient coverageAddedClient = SubscriptionClient.CreateFromConnectionString(connectionString, "PolicyEvents", "CoverageAddedEvent");
SubscriptionClient policyCreatedClient = SubscriptionClient.CreateFromConnectionString(connectionString, "PolicyEvents", "PolicyCreatedEvent");
Task recieveCoverageAddedTask = coverageAddedClient.ReceiveAsync().ContinueWith(ProcessCoverageAddedMessage);
Task recievePolicyCreateTask = policyCreatedClient.ReceiveAsync().ContinueWith(ProcessPolicyCreatedMessage);
Task.WaitAll(recieveCoverageAddedTask, recievePolicyCreateTask);
Console.WriteLine("All messages received");
}
static async void processAll(CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
var msg = await m_clientAll.ReceiveAsync(TimeSpan.FromSeconds(5));
if (msg != null)
{
Console.WriteLine($"ALERT: {msg.MessageId}");
await m_clientAll.CompleteAsync(msg.LockToken); //Yes, we processed "ALERT"
}
}
}
static async void processAll()
{
while (true)
{
var msg = await m_clientAll.ReceiveAsync();
if (msg != null)
{
Console.WriteLine($"ALERT: {msg.MessageId}");
await m_clientAll.CompleteAsync(msg.LockToken); //Yes, we processed "ALERT"
}
}
}
static async void processLog()
{
while (true)
{
var msg = await m_clientLog.ReceiveAsync();
if (msg != null)
{
Console.WriteLine($"LOG: {msg.MessageId}");
Param p = msg.GetBody <Param>();
Console.WriteLine($"LOG: {msg.MessageId}, {DateTime.Now.Ticks}: {p.A}, {p.B}");
await m_clientLog.CompleteAsync(msg.LockToken);
}
}
}
private async Task RunAsync(CancellationToken cancellationToken)
{
// TODO: Replace the following with your own logic.
while (!cancellationToken.IsCancellationRequested)
{
var msg = await m_client.ReceiveAsync(TimeSpan.FromSeconds(60));
if (msg != null)
{
var arr = msg.GetBody<byte[]>();
var msgResp = new BrokeredMessage(string.Format(" Średnia z elementów: " + arr.Average(a=>a)));
msgResp.SessionId = msg.ReplyToSessionId;
await m_queue.SendAsync(msgResp);
Trace.TraceInformation("wSuma: MessageId:{0}", msg.MessageId);
await msg.CompleteAsync();
}
}
}
protected override async Task StartAsync()
{
InfoLogging(string.Format("{0} - Processing", SubscriptionName));
_subClient = await _clientFactory.CreateSubscriptionClientAsync(TopicName, SubscriptionName).ConfigureAwait(false);
_retryStrategy = CreateRetryPolicy(MessageRepostMaxCount);
var stopWatch = new Stopwatch();
while (!Token.IsCancellationRequested)
{
var message = await _subClient.ReceiveAsync(new TimeSpan(0, 0, 10)).ConfigureAwait(false);
if (message == null) continue;
var messageBody = message.GetBody<string>();
if (String.IsNullOrEmpty(messageBody)) continue;
var messageId = message.MessageId;
message.Complete();
DebugLogging(string.Format("{0} - Received new message", SubscriptionName), messageId);
var failed = false;
stopWatch.Restart();
try
{
await _retryStrategy.ExecuteAsync(() =>
Do(messageBody), Token).ConfigureAwait(false);
stopWatch.Stop();
var timeSpan = stopWatch.Elapsed;
DebugLogging(string.Format("{0} - Processed message",
SubscriptionName), messageId,
timeSpan.TotalSeconds);
}
catch (Exception exception)
{
ErrorLogging("Message processing failed after retry, posting as failed message.", messageId,
exception);
failed = true;
}
if (failed)
await HandleFailedMessageAsync(messageBody).ConfigureAwait(false);
}
}
static async void processAdd()
{
while (true)
{
var msg = await m_clientAdd.ReceiveAsync();
if (msg != null)
{
Console.WriteLine($"ADD: {msg.MessageId}");
Param p = msg.GetBody <Param>();
Console.WriteLine($"ADD: {msg.MessageId}, {DateTime.Now.Ticks}: {p.A}, {p.B}");
BrokeredMessage msgResp = new BrokeredMessage(p.A + p.B);
msgResp.SessionId = msg.ReplyToSessionId;
await m_queue.SendAsync(msgResp);
await m_clientAdd.CompleteAsync(msg.LockToken);
}
}
}
private async Task<IEnumerable<string>> ProcessGetAsync(SubscriptionClient client)
{
var result = new List<string>();
var watch = new Stopwatch();
for (int i = 1; i < 11; i++)
{
watch.Restart();
BrokeredMessage message = await client.ReceiveAsync(new TimeSpan(0, 0, 5));
watch.Stop();
result.Add($"Azure Service Bus Topic {i} try: {watch.ElapsedMilliseconds}");
}
return result;
}
