protected override string FromAsText()
{
return(_from.ToString());
}
/// <summary>
/// Creates the AMQP link to be used for consumer-related operations.
/// </summary>
///
/// <param name="consumerGroup">The consumer group of the Event Hub to which the link is bound.</param>
/// <param name="partitionId">The identifier of the Event Hub partition to which the link is bound.</param>
/// <param name="consumerIdentifier">The identifier associated with the consumer.</param>
/// <param name="eventStartingPosition">The place within the partition's event stream to begin consuming events.</param>
/// <param name="prefetchCount">Controls the number of events received and queued locally without regard to whether an operation was requested.</param>
/// <param name="prefetchSizeInBytes">The cache size of the prefetch queue. When set, the link makes a best effort to ensure prefetched messages fit into the specified size.</param>
/// <param name="ownerLevel">The relative priority to associate with the link; for a non-exclusive link, this value should be <c>null</c>.</param>
/// <param name="trackLastEnqueuedEventProperties">Indicates whether information on the last enqueued event on the partition is sent as events are received.</param>
/// <param name="timeout">The timeout to apply for creating the link.</param>
/// <param name="cancellationToken">The cancellation token to consider when creating the link.</param>
///
/// <returns>The AMQP link to use for consumer-related operations.</returns>
///
protected async Task <ReceivingAmqpLink> CreateConsumerLinkAsync(string consumerGroup,
string partitionId,
string consumerIdentifier,
EventPosition eventStartingPosition,
uint prefetchCount,
long?prefetchSizeInBytes,
long?ownerLevel,
bool trackLastEnqueuedEventProperties,
TimeSpan timeout,
CancellationToken cancellationToken)
{
// Determine if there is an active is an active exception that needs to be surfaced,
// do so now.
//
// Note that this is a benign race; it is possible that multiple threads
// will observe the active exception and surface it, even if the consumer is not
// considered invalid. This is reasonable behavior for this scenario as the underlying
// condition is itself a race condition between multiple consumers.
var activeException = _activePartitionStolenException;
if (activeException != null)
{
// If the consumer should not be considered invalid, clear the active exception if
// it hasn't already been reset.
if (!InvalidateConsumerWhenPartitionStolen)
{
Interlocked.CompareExchange(ref _activePartitionStolenException, null, activeException);
}
EventHubsEventSource.Log.AmqpConsumerLinkCreateCapturedErrorThrow(EventHubName, consumerGroup, partitionId, ownerLevel?.ToString(CultureInfo.InvariantCulture), eventStartingPosition.ToString(), activeException.Message);
ExceptionDispatchInfo.Capture(activeException).Throw();
}
// Create and open the consumer link.
var link = default(ReceivingAmqpLink);
var tryTimeout = RetryPolicy.CalculateTryTimeout(0);
try
{
link = await ConnectionScope.OpenConsumerLinkAsync(
consumerGroup,
partitionId,
eventStartingPosition,
tryTimeout,
timeout,
prefetchCount,
prefetchSizeInBytes,
ownerLevel,
trackLastEnqueuedEventProperties,
consumerIdentifier,
cancellationToken).ConfigureAwait(false);
}
catch (Exception ex)
{
ExceptionDispatchInfo.Capture(ex.TranslateConnectionCloseDuringLinkCreationException(EventHubName)).Throw();
}
return(link);
}