public ReceiverPrepareState(ReceiverContext <T> logContext)
{
this._ctx = logContext;
_logTypes[0] = enLogType.API;
_logTypes[1] = enLogType.BO;
_logTypes[2] = enLogType.System;
}
public void ScenarioSetup()
{
this._senders = new List <SenderContext <object> >();
this._receiver = new ReceiverContext <object>();
this._checker = new Rediser(_redisConString);
}
public void AReceiverHasBeenInitiated()
{
this._receiver = new ReceiverContext <object>();
this._receiver.MsgConnection = new Rediser(_redisConString, SerializerType.NewtonJson);
this._receiver.DataConnection = new Rediser(_redisConString, SerializerType.NewtonJson);
this._receiver.Initial();
}
public void Initial()
{
this._ctx = new ReceiverContext <object>();
this._ctx.MsgConnection = Substitute.For <IRediser>();
this._ctx.DataConnection = Substitute.For <IRediser>();
this._ctx.DB = Substitute.For <IDBer>();
this._ctx.ES = Substitute.For <IESer>();
}
private async Task ProcessMessages(ReceiverContext receiverContext)
{
TimeSpan backoffAmount = _backoffTime;
while (!_cts.IsCancellationRequested)
{
try
{
var messages = await receiverContext.Receiver.ReceiveBatchAsync(
ReceiverContext.ReceiveBatchSize, receiverContext.ReceiveTimeout);
receiverContext.OnMessage(messages);
// Reset the receive timeout if it changed
receiverContext.ReceiveTimeout = DefaultReadTimeout;
continue;
}
catch (OperationCanceledException)
{
// This means the channel is closed
_trace.TraceError("Receiving messages from the service bus threw an OperationCanceledException, most likely due to a closed channel.");
return;
}
catch (MessagingEntityNotFoundException ex)
{
try
{
await receiverContext.Receiver.CloseAsync();
}
catch { }
receiverContext.OnError(ex);
var ignored = TryCreateSubscription(receiverContext);
return;
}
catch (ServerBusyException ex)
{
receiverContext.OnError(ex);
}
catch (Exception ex)
{
receiverContext.OnError(ex);
// TODO: Exponential backoff
backoffAmount = ErrorBackOffAmount;
// After an error, we want to adjust the timeout so that we
// can recover as quickly as possible even if there's no message
receiverContext.ReceiveTimeout = ErrorReadTimeout;
}
// back off for ServerBusyException and other exceptions not handled is a specific way
await Task.Delay(backoffAmount);
}
}
private void CreateSubscription(ServiceBusConnectionContext connectionContext, int topicIndex)
{
lock (connectionContext.SubscriptionsLock)
{
if (connectionContext.IsDisposed)
{
return;
}
string topicName = connectionContext.TopicNames[topicIndex];
// Create a random subscription
string subscriptionName = Guid.NewGuid().ToString();
try
{
var subscriptionDescription = new SubscriptionDescription(topicName, subscriptionName);
// This cleans up the subscription while if it's been idle for more than the timeout.
subscriptionDescription.AutoDeleteOnIdle = _idleSubscriptionTimeout;
_namespaceManager.CreateSubscription(subscriptionDescription);
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} in the service bus completed successfully.", subscriptionName, topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} threw an MessagingEntityAlreadyExistsException.", subscriptionName, topicName);
}
// Create a receiver to get messages
string subscriptionEntityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
MessageReceiver receiver = _factory.CreateMessageReceiver(subscriptionEntityPath, ReceiveMode.ReceiveAndDelete);
_trace.TraceInformation("Creation of a message receive for subscription entity path {0} in the service bus completed successfully.", subscriptionEntityPath);
connectionContext.SetSubscriptionContext(new SubscriptionContext(topicName, subscriptionName, receiver), topicIndex);
var receiverContext = new ReceiverContext(topicIndex, receiver, connectionContext);
var task = Task.Run(() => ProcessMessages(receiverContext));
_processMessagesTasks.GetOrAdd(task, false);
task.ContinueWith(t =>
{
bool value;
_processMessagesTasks.TryRemove(task, out value);
});
// Open the stream
connectionContext.OpenStream(topicIndex);
}
}
private bool ContinueReceiving(IAsyncResult asyncResult, ReceiverContext receiverContext)
{
bool shouldContinue = true;
TimeSpan backoffAmount = BackoffAmount;
try
{
IEnumerable <BrokeredMessage> messages = receiverContext.Receiver.EndReceiveBatch(asyncResult);
receiverContext.OnMessage(messages);
// Reset the receive timeout if it changed
receiverContext.ReceiveTimeout = DefaultReadTimeout;
}
catch (ServerBusyException ex)
{
receiverContext.OnError(ex);
// Too busy so back off
shouldContinue = false;
}
catch (OperationCanceledException)
{
// This means the channel is closed
_trace.TraceError("Receiving messages from the service bus threw an OperationCanceledException, most likely due to a closed channel.");
return(false);
}
catch (Exception ex)
{
receiverContext.OnError(ex);
shouldContinue = false;
// TODO: Exponential backoff
backoffAmount = ErrorBackOffAmount;
// After an error, we want to adjust the timeout so that we
// can recover as quickly as possible even if there's no message
receiverContext.ReceiveTimeout = ErrorReadTimeout;
}
if (!shouldContinue)
{
TaskAsyncHelper.Delay(backoffAmount)
.Then(ctx => ProcessMessages(ctx), receiverContext);
return(false);
}
return(true);
}
public void InitiateMulti_Receiver()
{
ReceiverContext <object> receiverA = new ReceiverContext <object>(),
receiverB = new ReceiverContext <object>();
receiverA.MsgConnection = new Rediser(_redisConString, SerializerType.NewtonJson);
receiverA.DataConnection = new Rediser(_redisConString, SerializerType.NewtonJson);
receiverB.MsgConnection = new Rediser(_redisConString, SerializerType.NewtonJson);
receiverB.DataConnection = new Rediser(_redisConString, SerializerType.NewtonJson);
receiverA.Initial();
receiverB.Initial();
this._receivers.Add(receiverA);
this._receivers.Add(receiverB);
}
private void ProcessMessages(ReceiverContext receiverContext)
{
receive:
try
{
IAsyncResult result = receiverContext.Receiver.BeginReceiveBatch(ReceiverContext.ReceiveBatchSize, receiverContext.ReceiveTimeout, ar =>
{
if (ar.CompletedSynchronously)
{
return;
}
var ctx = (ReceiverContext)ar.AsyncState;
if (ContinueReceiving(ar, ctx))
{
ProcessMessages(ctx);
}
},
receiverContext);
if (result.CompletedSynchronously)
{
if (ContinueReceiving(result, receiverContext))
{
goto receive;
}
}
}
catch (OperationCanceledException)
{
// This means the channel is closed
_trace.TraceError("OperationCanceledException was thrown in trying to receive the message from the service bus.");
return;
}
catch (Exception ex)
{
_trace.TraceError(ex.Message);
receiverContext.OnError(ex);
Thread.Sleep(RetryDelay);
goto receive;
}
}
private void ProcessMessages(ReceiverContext receiverContext)
{
receive:
try
{
IAsyncResult result = receiverContext.Receiver.BeginReceiveBatch(receiverContext.ReceiveBatchSize, receiverContext.ReceiveTimeout, ar =>
{
if (ar.CompletedSynchronously)
{
return;
}
var ctx = (ReceiverContext)ar.AsyncState;
if (ContinueReceiving(ar, ctx))
{
ProcessMessages(ctx);
}
},
receiverContext);
if (result.CompletedSynchronously)
{
if (ContinueReceiving(result, receiverContext))
{
goto receive;
}
}
}
catch (OperationCanceledException)
{
// This means the channel is closed
return;
}
catch (Exception ex)
{
receiverContext.OnError(ex);
// REVIEW: What should we do here?
}
}
private bool ContinueReceiving(IAsyncResult asyncResult, ReceiverContext receiverContext)
{
bool shouldContinue = true;
TimeSpan backoffAmount = BackoffAmount;
try
{
IEnumerable<BrokeredMessage> messages = receiverContext.Receiver.EndReceiveBatch(asyncResult);
receiverContext.OnMessage(messages);
// Reset the receive timeout if it changed
receiverContext.ReceiveTimeout = DefaultReadTimeout;
}
catch (ServerBusyException ex)
{
receiverContext.OnError(ex);
// Too busy so back off
shouldContinue = false;
}
catch (OperationCanceledException)
{
// This means the channel is closed
_trace.TraceError("Receiving messages from the service bus threw an OperationCanceledException, most likely due to a closed channel.");
return false;
}
catch (MessagingEntityNotFoundException ex)
{
receiverContext.Receiver.CloseAsync().Catch();
receiverContext.OnError(ex);
TaskAsyncHelper.Delay(RetryDelay)
.Then(() => Retry(() => CreateSubscription(receiverContext.ConnectionContext, receiverContext.TopicIndex)));
return false;
}
catch (Exception ex)
{
receiverContext.OnError(ex);
shouldContinue = false;
// TODO: Exponential backoff
backoffAmount = ErrorBackOffAmount;
// After an error, we want to adjust the timeout so that we
// can recover as quickly as possible even if there's no message
receiverContext.ReceiveTimeout = ErrorReadTimeout;
}
if (!shouldContinue)
{
TaskAsyncHelper.Delay(backoffAmount)
.Then(ctx => ProcessMessages(ctx), receiverContext);
return false;
}
return true;
}
private void ProcessMessages(ReceiverContext receiverContext)
{
receive:
try
{
IAsyncResult result = receiverContext.Receiver.BeginReceiveBatch(ReceiverContext.ReceiveBatchSize, receiverContext.ReceiveTimeout, ar =>
{
if (ar.CompletedSynchronously)
{
return;
}
var ctx = (ReceiverContext)ar.AsyncState;
if (ContinueReceiving(ar, ctx))
{
ProcessMessages(ctx);
}
},
receiverContext);
if (result.CompletedSynchronously)
{
if (ContinueReceiving(result, receiverContext))
{
goto receive;
}
}
}
catch (OperationCanceledException)
{
// This means the channel is closed
_trace.TraceError("OperationCanceledException was thrown in trying to receive the message from the service bus.");
return;
}
catch (Exception ex)
{
_trace.TraceError(ex.Message);
receiverContext.OnError(ex);
Thread.Sleep(RetryDelay);
goto receive;
}
}
private void CreateSubscription(ServiceBusConnectionContext connectionContext, int topicIndex)
{
lock (connectionContext.SubscriptionsLock)
{
if (connectionContext.IsDisposed)
{
return;
}
string topicName = connectionContext.TopicNames[topicIndex];
// Create a random subscription
string subscriptionName = Guid.NewGuid().ToString();
try
{
var subscriptionDescription = new SubscriptionDescription(topicName, subscriptionName);
// This cleans up the subscription while if it's been idle for more than the timeout.
subscriptionDescription.AutoDeleteOnIdle = _idleSubscriptionTimeout;
_namespaceManager.CreateSubscription(subscriptionDescription);
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} in the service bus completed successfully.", subscriptionName, topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} threw an MessagingEntityAlreadyExistsException.", subscriptionName, topicName);
}
// Create a receiver to get messages
string subscriptionEntityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
MessageReceiver receiver = _factory.CreateMessageReceiver(subscriptionEntityPath, ReceiveMode.ReceiveAndDelete);
_trace.TraceInformation("Creation of a message receive for subscription entity path {0} in the service bus completed successfully.", subscriptionEntityPath);
connectionContext.SetSubscriptionContext(new SubscriptionContext(topicName, subscriptionName, receiver), topicIndex);
var receiverContext = new ReceiverContext(topicIndex, receiver, connectionContext);
ProcessMessages(receiverContext);
// Open the stream
connectionContext.OpenStream(topicIndex);
}
}
public ServiceBusSubscription Subscribe(IList<string> topicNames,
Action<int, IEnumerable<BrokeredMessage>> handler,
Action<int, Exception> errorHandler)
{
if (topicNames == null)
{
throw new ArgumentNullException("topicNames");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
_trace.TraceInformation("Subscribing to {0} topic(s) in the service bus...", topicNames.Count);
var subscriptions = new ServiceBusSubscription.SubscriptionContext[topicNames.Count];
var clients = new TopicClient[topicNames.Count];
for (var topicIndex = 0; topicIndex < topicNames.Count; ++topicIndex)
{
string topicName = topicNames[topicIndex];
if (!_namespaceManager.TopicExists(topicName))
{
try
{
_trace.TraceInformation("Creating a new topic {0} in the service bus...", topicName);
_namespaceManager.CreateTopic(topicName);
_trace.TraceInformation("Creation of a new topic {0} in the service bus completed successfully.", topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
_trace.TraceInformation("Creation of a new topic {0} threw an MessagingEntityAlreadyExistsException.", topicName);
}
}
// Create a client for this topic
clients[topicIndex] = TopicClient.CreateFromConnectionString(_configuration.ConnectionString, topicName);
_trace.TraceInformation("Creation of a new topic client {0} completed successfully.", topicName);
// Create a random subscription
string subscriptionName = Guid.NewGuid().ToString();
try
{
var subscriptionDescription = new SubscriptionDescription(topicName, subscriptionName);
// This cleans up the subscription while if it's been idle for more than the timeout.
subscriptionDescription.AutoDeleteOnIdle = IdleSubscriptionTimeout;
_namespaceManager.CreateSubscription(subscriptionDescription);
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} in the service bus completed successfully.", subscriptionName, topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} threw an MessagingEntityAlreadyExistsException.", subscriptionName, topicName);
}
// Create a receiver to get messages
string subscriptionEntityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
MessageReceiver receiver = _factory.CreateMessageReceiver(subscriptionEntityPath, ReceiveMode.ReceiveAndDelete);
_trace.TraceInformation("Creation of a message receive for subscription entity path {0} in the service bus completed successfully.", subscriptionEntityPath);
subscriptions[topicIndex] = new ServiceBusSubscription.SubscriptionContext(topicName, subscriptionName, receiver);
var receiverContext = new ReceiverContext(topicIndex, receiver, handler, errorHandler);
ProcessMessages(receiverContext);
}
_trace.TraceInformation("Subscription to {0} topics in the service bus Topic service completed successfully.", topicNames.Count);
return new ServiceBusSubscription(_configuration, _namespaceManager, subscriptions, clients);
}
public ServiceBusSubscription Subscribe(IList <string> topicNames,
Action <int, IEnumerable <BrokeredMessage> > handler,
Action <int, Exception> errorHandler)
{
if (topicNames == null)
{
throw new ArgumentNullException("topicNames");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
_trace.TraceInformation("Subscribing to {0} topic(s) in the service bus...", topicNames.Count);
var subscriptions = new ServiceBusSubscription.SubscriptionContext[topicNames.Count];
var clients = new TopicClient[topicNames.Count];
for (var topicIndex = 0; topicIndex < topicNames.Count; ++topicIndex)
{
string topicName = topicNames[topicIndex];
if (!_namespaceManager.TopicExists(topicName))
{
try
{
_trace.TraceInformation("Creating a new topic {0} in the service bus...", topicName);
_namespaceManager.CreateTopic(topicName);
_trace.TraceInformation("Creation of a new topic {0} in the service bus completed successfully.", topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
_trace.TraceInformation("Creation of a new topic {0} threw an MessagingEntityAlreadyExistsException.", topicName);
}
}
// Create a client for this topic
clients[topicIndex] = TopicClient.CreateFromConnectionString(_configuration.ConnectionString, topicName);
_trace.TraceInformation("Creation of a new topic client {0} completed successfully.", topicName);
// Create a random subscription
string subscriptionName = Guid.NewGuid().ToString();
try
{
var subscriptionDescription = new SubscriptionDescription(topicName, subscriptionName);
// This cleans up the subscription while if it's been idle for more than the timeout.
subscriptionDescription.AutoDeleteOnIdle = IdleSubscriptionTimeout;
_namespaceManager.CreateSubscription(subscriptionDescription);
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} in the service bus completed successfully.", subscriptionName, topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
_trace.TraceInformation("Creation of a new subscription {0} for topic {1} threw an MessagingEntityAlreadyExistsException.", subscriptionName, topicName);
}
// Create a receiver to get messages
string subscriptionEntityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
MessageReceiver receiver = _factory.CreateMessageReceiver(subscriptionEntityPath, ReceiveMode.ReceiveAndDelete);
_trace.TraceInformation("Creation of a message receive for subscription entity path {0} in the service bus completed successfully.", subscriptionEntityPath);
subscriptions[topicIndex] = new ServiceBusSubscription.SubscriptionContext(topicName, subscriptionName, receiver);
var receiverContext = new ReceiverContext(topicIndex, receiver, handler, errorHandler);
ProcessMessages(receiverContext);
}
_trace.TraceInformation("Subscription to {0} topics in the service bus Topic service completed successfully.", topicNames.Count);
return(new ServiceBusSubscription(_configuration, _namespaceManager, subscriptions, clients));
}
public ServiceBusSubscription Subscribe(IList <string> topicNames,
Action <int, IEnumerable <BrokeredMessage> > handler,
Action <int, Exception> errorHandler)
{
if (topicNames == null)
{
throw new ArgumentNullException("topicNames");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
var subscriptions = new ServiceBusSubscription.SubscriptionContext[topicNames.Count];
var clients = new TopicClient[topicNames.Count];
for (var topicIndex = 0; topicIndex < topicNames.Count; ++topicIndex)
{
string topicName = topicNames[topicIndex];
if (!_namespaceManager.TopicExists(topicName))
{
try
{
_namespaceManager.CreateTopic(topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
}
}
// Create a client for this topic
clients[topicIndex] = TopicClient.CreateFromConnectionString(_configuration.ConnectionString, topicName);
// Create a random subscription
string subscriptionName = Guid.NewGuid().ToString();
try
{
_namespaceManager.CreateSubscription(topicName, subscriptionName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
}
// Create a receiver to get messages
string subscriptionEntityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
MessageReceiver receiver = _factory.CreateMessageReceiver(subscriptionEntityPath, ReceiveMode.ReceiveAndDelete);
subscriptions[topicIndex] = new ServiceBusSubscription.SubscriptionContext(topicName, subscriptionName, receiver);
var receiverContext = new ReceiverContext(topicIndex, receiver, handler, errorHandler);
ProcessMessages(receiverContext);
}
return(new ServiceBusSubscription(_configuration, _namespaceManager, subscriptions, clients));
}
public ReceiverItem(ReceiverContext <DTO> _receiver)
{
this._receiver = _receiver;
}
public ReceiverInitialState(ReceiverContext <T> logContext)
{
_ctx = logContext;
}
private bool ContinueReceiving(IAsyncResult asyncResult, ReceiverContext receiverContext)
{
bool shouldContinue = true;
TimeSpan backoffAmount = _backoffTime;
try
{
IEnumerable <BrokeredMessage> messages = receiverContext.Receiver.EndReceiveBatch(asyncResult);
receiverContext.OnMessage(messages);
// Reset the receive timeout if it changed
receiverContext.ReceiveTimeout = DefaultReadTimeout;
}
catch (ServerBusyException ex)
{
receiverContext.OnError(ex);
// Too busy so back off
shouldContinue = false;
}
catch (OperationCanceledException)
{
// This means the channel is closed
_logger.LogError("Receiving messages from the service bus threw an OperationCanceledException, most likely due to a closed channel.");
return(false);
}
catch (MessagingEntityNotFoundException ex)
{
receiverContext.Receiver.CloseAsync()
.ContinueWith(t => _logger.LogInformation("{0}", t.Exception.ToString()), TaskContinuationOptions.OnlyOnFaulted);
receiverContext.OnError(ex);
Task.Run(async() =>
{
await Task.Delay(RetryDelay);
Retry(() => CreateSubscription(receiverContext.ConnectionContext, receiverContext.TopicIndex));
});
return(false);
}
catch (Exception ex)
{
receiverContext.OnError(ex);
shouldContinue = false;
// TODO: Exponential backoff
backoffAmount = ErrorBackOffAmount;
// After an error, we want to adjust the timeout so that we
// can recover as quickly as possible even if there's no message
receiverContext.ReceiveTimeout = ErrorReadTimeout;
}
if (!shouldContinue)
{
Task.Run(async() =>
{
await Task.Delay(backoffAmount);
ProcessMessages(receiverContext);
});
return(false);
}
return(true);
}
public ReceiverProcessState(ReceiverContext <T> logContext)
{
this._ctx = logContext;
}
private async Task TryCreateSubscription(ReceiverContext receiverContext)
{
await Task.Delay(RetryDelay);
Retry(() => CreateSubscription(receiverContext.ConnectionContext, receiverContext.TopicIndex));
}
private bool ContinueReceiving(IAsyncResult asyncResult, ReceiverContext receiverContext)
{
bool shouldContinue = true;
TimeSpan backoffAmount = BackoffAmount;
try
{
IEnumerable<BrokeredMessage> messages = receiverContext.Receiver.EndReceiveBatch(asyncResult);
receiverContext.OnMessage(messages);
// Reset the receive timeout if it changed
receiverContext.ReceiveTimeout = DefaultReadTimeout;
}
catch (ServerBusyException ex)
{
receiverContext.OnError(ex);
// Too busy so back off
shouldContinue = false;
}
catch (OperationCanceledException)
{
// This means the channel is closed
return false;
}
catch (Exception ex)
{
receiverContext.OnError(ex);
shouldContinue = false;
// TODO: Exponential backoff
backoffAmount = ErrorBackOffAmount;
// After an error, we want to adjust the timeout so that we
// can recover as quickly as possible even if there's no message
receiverContext.ReceiveTimeout = ErrorReadTimeout;
}
if (!shouldContinue)
{
TaskAsyncHelper.Delay(backoffAmount)
.Then(ctx => ProcessMessages(ctx), receiverContext);
return false;
}
return true;
}
private void ProcessMessages(ReceiverContext receiverContext)
{
receive:
try
{
IAsyncResult result = receiverContext.Receiver.BeginReceiveBatch(receiverContext.ReceiveBatchSize, receiverContext.ReceiveTimeout, ar =>
{
if (ar.CompletedSynchronously)
{
return;
}
var ctx = (ReceiverContext)ar.AsyncState;
if (ContinueReceiving(ar, ctx))
{
ProcessMessages(ctx);
}
},
receiverContext);
if (result.CompletedSynchronously)
{
if (ContinueReceiving(result, receiverContext))
{
goto receive;
}
}
}
catch (OperationCanceledException)
{
// This means the channel is closed
return;
}
catch (Exception ex)
{
receiverContext.OnError(ex);
// REVIEW: What should we do here?
}
}
public ServiceBusSubscription Subscribe(IList<string> topicNames,
Action<int, IEnumerable<BrokeredMessage>> handler,
Action<int, Exception> errorHandler)
{
if (topicNames == null)
{
throw new ArgumentNullException("topicNames");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
var subscriptions = new ServiceBusSubscription.SubscriptionContext[topicNames.Count];
var clients = new TopicClient[topicNames.Count];
for (var topicIndex = 0; topicIndex < topicNames.Count; ++topicIndex)
{
string topicName = topicNames[topicIndex];
if (!_namespaceManager.TopicExists(topicName))
{
try
{
_namespaceManager.CreateTopic(topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
}
}
// Create a client for this topic
clients[topicIndex] = TopicClient.CreateFromConnectionString(_configuration.ConnectionString, topicName);
// Create a random subscription
string subscriptionName = Guid.NewGuid().ToString();
try
{
_namespaceManager.CreateSubscription(topicName, subscriptionName);
}
catch (MessagingEntityAlreadyExistsException)
{
// The entity already exists
}
// Create a receiver to get messages
string subscriptionEntityPath = SubscriptionClient.FormatSubscriptionPath(topicName, subscriptionName);
MessageReceiver receiver = _factory.CreateMessageReceiver(subscriptionEntityPath, ReceiveMode.ReceiveAndDelete);
subscriptions[topicIndex] = new ServiceBusSubscription.SubscriptionContext(topicName, subscriptionName, receiver);
var receiverContext = new ReceiverContext(topicIndex, receiver, handler, errorHandler);
ProcessMessages(receiverContext);
}
return new ServiceBusSubscription(_configuration, _namespaceManager, subscriptions, clients);
}
public void Finished()
{
this._ctx.MsgConnection = null;
this._ctx.DataConnection = null;
this._ctx = null;
}
public ReceiverContext receiver() {
ReceiverContext _localctx = new ReceiverContext(_ctx, State);
EnterRule(_localctx, 100, RULE_receiver);
try {
State = 696;
switch ( Interpreter.AdaptivePredict(_input,62,_ctx) ) {
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 693; expression();
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 694; class_name();
}
break;
case 3:
EnterOuterAlt(_localctx, 3);
{
State = 695; Match(SUPER);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return _localctx;
}
