/// <summary>
/// Cancels a message that was scheduled.
/// </summary>
/// <param name="sequenceNumber">The <see cref="ServiceBusMessage.SystemPropertiesCollection.SequenceNumber"/> of the message to be cancelled.</param>
/// <param name="retryPolicy"></param>
/// <param name="sendLinkName"></param>
/// <param name="cancellationToken"></param>
internal async Task CancelScheduledMessageAsync(
long sequenceNumber,
ServiceBusRetryPolicy retryPolicy,
string sendLinkName = null,
CancellationToken cancellationToken = default) =>
await InnerClient.CancelScheduledMessageAsync(sequenceNumber, retryPolicy, sendLinkName, cancellationToken)
.ConfigureAwait(false);
internal ServiceBusSession(
TransportConsumer consumer,
ServiceBusRetryPolicy retryPolicy)
{
_consumer = consumer;
_retryPolicy = retryPolicy;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceBusSender"/> class.
/// </summary>
/// <param name="entityPath">The entity path to send the message to.</param>
/// <param name="options">The set of <see cref="ServiceBusSenderOptions"/> to use for configuring
/// this <see cref="ServiceBusSender"/>.</param>
/// <param name="connection">The connection for the sender.</param>
///
internal ServiceBusSender(
string entityPath,
ServiceBusSenderOptions options,
ServiceBusConnection connection)
{
Logger.ClientCreateStart(typeof(ServiceBusSender), connection?.FullyQualifiedNamespace, entityPath);
try
{
Argument.AssertNotNull(connection, nameof(connection));
Argument.AssertNotNull(connection.RetryOptions, nameof(connection.RetryOptions));
Argument.AssertNotNullOrWhiteSpace(entityPath, nameof(entityPath));
connection.ThrowIfClosed();
options = options?.Clone() ?? new ServiceBusSenderOptions();
EntityPath = entityPath;
ViaEntityPath = options.ViaQueueOrTopicName;
Identifier = DiagnosticUtilities.GenerateIdentifier(EntityPath);
_connection = connection;
_retryPolicy = _connection.RetryOptions.ToRetryPolicy();
_innerSender = _connection.CreateTransportSender(
entityPath,
ViaEntityPath,
_retryPolicy,
Identifier);
_scopeFactory = new EntityScopeFactory(EntityPath, FullyQualifiedNamespace);
}
catch (Exception ex)
{
Logger.ClientCreateException(typeof(ServiceBusSender), connection?.FullyQualifiedNamespace, entityPath, ex);
throw;
}
Logger.ClientCreateComplete(typeof(ServiceBusSender), Identifier);
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="retryPolicy"></param>
/// <param name="sendLinkName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
internal async Task <long> ScheduleMessageAsync(
ServiceBusMessage message,
ServiceBusRetryPolicy retryPolicy,
string sendLinkName = null,
CancellationToken cancellationToken = default) =>
await InnerClient.ScheduleMessageAsync(message, retryPolicy, sendLinkName, cancellationToken)
.ConfigureAwait(false);
/// <summary>
/// Initializes a new instance of the <see cref="ServiceBusReceiver"/> class.
/// </summary>
///
/// <param name="connection">The <see cref="ServiceBusConnection" /> connection to use for communication with the Service Bus service.</param>
/// <param name="entityPath"></param>
/// <param name="isSessionEntity"></param>
/// <param name="options">A set of options to apply when configuring the consumer.</param>
/// <param name="sessionId"></param>
///
internal ServiceBusReceiver(
ServiceBusConnection connection,
string entityPath,
bool isSessionEntity,
ServiceBusReceiverOptions options,
string sessionId = default)
{
Argument.AssertNotNull(connection, nameof(connection));
Argument.AssertNotNull(connection.RetryOptions, nameof(connection.RetryOptions));
Argument.AssertNotNullOrWhiteSpace(entityPath, nameof(entityPath));
connection.ThrowIfClosed();
options = options?.Clone() ?? new ServiceBusReceiverOptions();
Identifier = DiagnosticUtilities.GenerateIdentifier(entityPath);
_connection = connection;
_retryPolicy = connection.RetryOptions.ToRetryPolicy();
ReceiveMode = options.ReceiveMode;
PrefetchCount = options.PrefetchCount;
EntityPath = entityPath;
IsSessionReceiver = isSessionEntity;
InnerReceiver = _connection.CreateTransportReceiver(
entityPath: EntityPath,
retryPolicy: _retryPolicy,
receiveMode: ReceiveMode,
prefetchCount: (uint)PrefetchCount,
identifier: Identifier,
sessionId: sessionId,
isSessionReceiver: IsSessionReceiver);
}
/// <summary>
/// Creates a consumer strongly aligned with the active protocol and transport, responsible
/// for reading <see cref="ServiceBusMessage" /> from a specific Service Bus entity partition, in the context
/// of a specific consumer group.
///
/// A consumer may be exclusive, which asserts ownership over the partition for the consumer
/// group to ensure that only one consumer from that group is reading the from the partition.
/// These exclusive consumers are sometimes referred to as "Epoch Consumers."
///
/// A consumer may also be non-exclusive, allowing multiple consumers from the same consumer
/// group to be actively reading events from the partition. These non-exclusive consumers are
/// sometimes referred to as "Non-epoch Consumers."
///
/// Designating a consumer as exclusive may be specified by setting the <paramref name="ownerLevel" />.
/// When <c>null</c>, consumers are created as non-exclusive.
/// </summary>
///
/// <param name="retryPolicy">The policy which governs retry behavior and try timeouts.</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="prefetchCount">Controls the number of events received and queued locally without regard to whether an operation was requested. If <c>null</c> a default will be used.</param>
/// <param name="sessionId"></param>
///
/// <returns>A <see cref="TransportConsumer" /> configured in the requested manner.</returns>
///
internal virtual TransportConsumer CreateTransportConsumer(
ServiceBusRetryPolicy retryPolicy,
long?ownerLevel = default,
uint?prefetchCount = default,
string sessionId = default)
{
Argument.AssertNotNull(retryPolicy, nameof(retryPolicy));
return(InnerClient.CreateConsumer(retryPolicy, ownerLevel, prefetchCount, sessionId));
}
/// <summary>
///
/// </summary>
/// <param name="retryPolicy"></param>
/// <param name="fromSequenceNumber"></param>
/// <param name="messageCount"></param>
/// <param name="sessionId"></param>
/// <param name="receiveLinkName"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
internal virtual async Task <IEnumerable <ServiceBusMessage> > PeekAsync(
ServiceBusRetryPolicy retryPolicy,
long?fromSequenceNumber,
int messageCount = 1,
string sessionId = null,
string receiveLinkName = null,
CancellationToken cancellationToken = default) =>
await InnerClient.PeekAsync(retryPolicy, fromSequenceNumber, messageCount, sessionId, receiveLinkName, cancellationToken)
.ConfigureAwait(false);
/// <summary>
/// Creates a consumer strongly aligned with the active protocol and transport, responsible
/// for reading <see cref="ServiceBusMessage" /> from a specific Service Bus entity.
/// </summary>
///
/// <param name="retryPolicy">The policy which governs retry behavior and try timeouts.</param>
/// <param name="receiveMode">The <see cref="ReceiveMode"/> used to specify how messages are received. Defaults to PeekLock mode.</param>
/// <param name="prefetchCount">Controls the number of events received and queued locally without regard to whether an operation was requested. If <c>null</c> a default will be used.</param>
/// <param name="sessionId"></param>
/// <param name="isSessionReceiver"></param>
///
/// <returns>A <see cref="TransportConsumer" /> configured in the requested manner.</returns>
///
internal virtual TransportConsumer CreateTransportConsumer(
ServiceBusRetryPolicy retryPolicy,
ReceiveMode receiveMode = default,
uint?prefetchCount = default,
string sessionId = default,
bool isSessionReceiver = default)
{
Argument.AssertNotNull(retryPolicy, nameof(retryPolicy));
return(InnerClient.CreateConsumer(retryPolicy, receiveMode, prefetchCount, sessionId, isSessionReceiver));
}
internal TransportReceiver CreateTransportReceiver(
string entityName,
ServiceBusRetryPolicy retryPolicy,
ReceiveMode receiveMode,
uint prefetchCount,
string sessionId = default,
bool isSessionReceiver = default) =>
_innerClient.CreateReceiver(
entityName,
retryPolicy,
receiveMode,
prefetchCount,
sessionId,
isSessionReceiver);
/// <summary>
/// Initializes a new instance of the <see cref="ServiceBusReceiver"/> class.
/// </summary>
///
/// <param name="connection">The <see cref="ServiceBusConnection" /> connection to use for communication with the Service Bus service.</param>
/// <param name="entityPath"></param>
/// <param name="isSessionEntity"></param>
/// <param name="plugins">The plugins to apply to incoming messages.</param>
/// <param name="options">A set of options to apply when configuring the consumer.</param>
/// <param name="sessionId">An optional session Id to scope the receiver to. If not specified,
/// the next available session returned from the service will be used.</param>
///
internal ServiceBusReceiver(
ServiceBusConnection connection,
string entityPath,
bool isSessionEntity,
IList <ServiceBusPlugin> plugins,
ServiceBusReceiverOptions options,
string sessionId = default)
{
Type type = GetType();
Logger.ClientCreateStart(type, connection?.FullyQualifiedNamespace, entityPath);
try
{
Argument.AssertNotNull(connection, nameof(connection));
Argument.AssertNotNull(connection.RetryOptions, nameof(connection.RetryOptions));
Argument.AssertNotNullOrWhiteSpace(entityPath, nameof(entityPath));
connection.ThrowIfClosed();
options = options?.Clone() ?? new ServiceBusReceiverOptions();
Identifier = DiagnosticUtilities.GenerateIdentifier(entityPath);
_connection = connection;
_retryPolicy = connection.RetryOptions.ToRetryPolicy();
ReceiveMode = options.ReceiveMode;
PrefetchCount = options.PrefetchCount;
EntityPath = entityPath;
IsSessionReceiver = isSessionEntity;
_innerReceiver = _connection.CreateTransportReceiver(
entityPath: EntityPath,
retryPolicy: _retryPolicy,
receiveMode: ReceiveMode,
prefetchCount: (uint)PrefetchCount,
identifier: Identifier,
sessionId: sessionId,
isSessionReceiver: IsSessionReceiver);
_scopeFactory = new EntityScopeFactory(EntityPath, FullyQualifiedNamespace);
_plugins = plugins;
if (!isSessionEntity)
{
// don't log client completion for session receiver here as it is not complete until
// the link is opened.
Logger.ClientCreateComplete(type, Identifier);
}
}
catch (Exception ex)
{
Logger.ClientCreateException(type, connection?.FullyQualifiedNamespace, entityPath, ex);
throw;
}
}
internal virtual TransportReceiver CreateTransportReceiver(
string entityPath,
ServiceBusRetryPolicy retryPolicy,
ServiceBusReceiveMode receiveMode,
uint prefetchCount,
string identifier,
string sessionId,
bool isSessionReceiver) =>
_innerClient.CreateReceiver(
entityPath,
retryPolicy,
receiveMode,
prefetchCount,
identifier,
sessionId,
isSessionReceiver);
/// <summary>
/// Initializes a new instance of the <see cref="ServiceBusSender"/> class.
/// </summary>
/// <param name="entityPath">The entity path to send the message to.</param>
/// <param name="connection">The connection for the sender.</param>
///
internal ServiceBusSender(
string entityPath,
ServiceBusConnection connection)
{
Argument.AssertNotNull(connection, nameof(connection));
Argument.AssertNotNull(connection.RetryOptions, nameof(connection.RetryOptions));
Argument.AssertNotNullOrWhiteSpace(entityPath, nameof(entityPath));
connection.ThrowIfClosed();
EntityPath = entityPath;
Identifier = DiagnosticUtilities.GenerateIdentifier(EntityPath);
_connection = connection;
_retryPolicy = _connection.RetryOptions.ToRetryPolicy();
_innerSender = _connection.CreateTransportSender(
entityPath,
_retryPolicy);
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceBusSender"/> class.
/// </summary>
/// <param name="connection"></param>
/// <param name="options">A set of options to apply when configuring the producer.</param>
/// <param name="entityName"></param>
/// <remarks>
/// If the connection string is copied from the Service Bus entity itself, it will contain the name of the desired Service Bus entity,
/// and can be used directly without passing the name="entityName" />. The name of the Service Bus entity should be
/// passed only once, either as part of the connection string or separately.
/// </remarks>
///
internal ServiceBusSender(
ServiceBusConnection connection,
ServiceBusSenderOptions options,
string entityName)
{
if (entityName == null)
{
throw new ArgumentException();
}
options = options?.Clone() ?? new ServiceBusSenderOptions();
ClientDiagnostics = new ClientDiagnostics(options);
OwnsConnection = false;
EntityName = entityName;
_connection = connection;
_retryPolicy = options.RetryOptions.ToRetryPolicy();
_innerSender = _connection.CreateTransportSender(
entityName,
_retryPolicy);
}
internal virtual TransportReceiver CreateTransportReceiver(
string entityPath,
ServiceBusRetryPolicy retryPolicy,
ServiceBusReceiveMode receiveMode,
uint prefetchCount,
string identifier,
string sessionId,
bool isSessionReceiver,
bool isProcessor,
CancellationToken cancellationToken) =>
InnerClient.CreateReceiver(
entityPath,
retryPolicy,
receiveMode,
prefetchCount,
identifier,
sessionId,
isSessionReceiver,
isProcessor,
cancellationToken);
/// <summary>
/// Creates a producer strongly aligned with the active protocol and transport,
/// responsible for publishing <see cref="ServiceBusMessage" /> to the Service Bus entity.
/// </summary>
///
/// <param name="retryPolicy">The policy which governs retry behavior and try timeouts.</param>
///
/// <returns>A <see cref="TransportSender"/> configured in the requested manner.</returns>
///
internal virtual TransportSender CreateTransportProducer(ServiceBusRetryPolicy retryPolicy)
{
Argument.AssertNotNull(retryPolicy, nameof(retryPolicy));
return(InnerClient.CreateSender(retryPolicy));
}
internal TransportSender CreateTransportSender(string entityName, ServiceBusRetryPolicy retryPolicy) => _innerClient.CreateSender(entityName, retryPolicy);
internal virtual TransportSender CreateTransportSender(
string entityPath,
string viaEntityPath,
ServiceBusRetryPolicy retryPolicy) =>
_innerClient.CreateSender(entityPath, viaEntityPath, retryPolicy);
internal virtual TransportSender CreateTransportSender(
string entityPath,
ServiceBusRetryPolicy retryPolicy,
string identifier) =>
_innerClient.CreateSender(entityPath, retryPolicy, identifier);
internal virtual TransportRuleManager CreateTransportRuleManager(
string subscriptionPath,
ServiceBusRetryPolicy retryPolicy,
string identifier) =>
InnerClient.CreateRuleManager(subscriptionPath, retryPolicy, identifier);
internal virtual TransportRuleManager CreateTransportRuleManager(
string subscriptionPath,
ServiceBusRetryPolicy retryPolicy) =>
_innerClient.CreateRuleManager(subscriptionPath, retryPolicy);