/// <summary> /// Gets the session state. /// </summary> /// /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <returns>The session state as <see cref="BinaryData"/>.</returns> /// <exception cref="ServiceBusException"> /// The lock for the session has expired. /// The <see cref="ServiceBusException.Reason" /> will be set to <see cref="ServiceBusFailureReason.SessionLockLost"/> in this case. /// </exception> public virtual async Task <BinaryData> GetSessionStateAsync(CancellationToken cancellationToken = default) { Argument.AssertNotDisposed(IsClosed, nameof(ServiceBusSessionReceiver)); _connection.ThrowIfClosed(); cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>(); Logger.GetSessionStateStart(Identifier, SessionId); using DiagnosticScope scope = ScopeFactory.CreateScope( DiagnosticProperty.GetSessionStateActivityName, DiagnosticProperty.ClientKind); scope.Start(); BinaryData sessionState; try { sessionState = await InnerReceiver.GetStateAsync(cancellationToken).ConfigureAwait(false); } catch (Exception exception) { Logger.GetSessionStateException(Identifier, exception.ToString()); scope.Failed(exception); throw; } Logger.GetSessionStateComplete(Identifier); return(sessionState); }
/// <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> /// 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> /// Initializes a new instance of the <see cref="ServiceBusProcessor"/> class. /// </summary> /// /// <param name="connection">The <see cref="ServiceBusConnection" /> connection to use for communication with the Service Bus service.</param> /// <param name="entityPath">The queue name or subscription path to process messages from.</param> /// <param name="isSessionEntity">Whether or not the processor is associated with a session entity.</param> /// <param name="plugins">The set of plugins to apply to incoming messages.</param> /// <param name="options">The set of options to use when configuring the processor.</param> /// <param name="sessionIds">An optional set of session Ids to limit processing to. /// Only applies if isSessionEntity is true.</param> /// <param name="maxConcurrentSessions">The max number of sessions that can be processed concurrently. /// Only applies if isSessionEntity is true.</param> /// <param name="maxConcurrentCallsPerSession">The max number of concurrent calls per session. /// Only applies if isSessionEntity is true.</param> internal ServiceBusProcessor( ServiceBusConnection connection, string entityPath, bool isSessionEntity, IList <ServiceBusPlugin> plugins, ServiceBusProcessorOptions options, string[] sessionIds = default, int maxConcurrentSessions = default, int maxConcurrentCallsPerSession = default) { Argument.AssertNotNullOrWhiteSpace(entityPath, nameof(entityPath)); Argument.AssertNotNull(connection, nameof(connection)); Argument.AssertNotNull(connection.RetryOptions, nameof(connection.RetryOptions)); connection.ThrowIfClosed(); _options = options?.Clone() ?? new ServiceBusProcessorOptions(); _connection = connection; EntityPath = entityPath; Identifier = DiagnosticUtilities.GenerateIdentifier(EntityPath); ReceiveMode = _options.ReceiveMode; PrefetchCount = _options.PrefetchCount; MaxAutoLockRenewalDuration = _options.MaxAutoLockRenewalDuration; MaxConcurrentCalls = _options.MaxConcurrentCalls; MaxConcurrentSessions = maxConcurrentSessions; MaxConcurrentCallsPerSession = maxConcurrentCallsPerSession; _sessionIds = sessionIds ?? Array.Empty <string>(); int maxCalls = isSessionEntity ? (_sessionIds.Length > 0 ? Math.Min(_sessionIds.Length, MaxConcurrentSessions) : MaxConcurrentSessions) * MaxConcurrentCallsPerSession : MaxConcurrentCalls; MessageHandlerSemaphore = new SemaphoreSlim( maxCalls, maxCalls); var maxAcceptSessions = Math.Min(maxCalls, 2 * Environment.ProcessorCount); MaxConcurrentAcceptSessionsSemaphore = new SemaphoreSlim( maxAcceptSessions, maxAcceptSessions); MaxReceiveWaitTime = _options.MaxReceiveWaitTime; AutoComplete = _options.AutoComplete; EntityPath = entityPath; IsSessionProcessor = isSessionEntity; _scopeFactory = new EntityScopeFactory(EntityPath, FullyQualifiedNamespace); _plugins = plugins; }
/// <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; } }
/// <summary> /// Initializes a new instance of the <see cref="ServiceBusRuleManager"/> class. /// </summary> /// /// <param name="connection">The <see cref="ServiceBusConnection" /> connection to use for communication with the Service Bus service.</param> /// <param name="subscriptionPath">The path of the Service Bus subscription to which the rule manager is bound.</param> /// internal ServiceBusRuleManager( ServiceBusConnection connection, string subscriptionPath) { Argument.AssertNotNull(connection, nameof(connection)); Argument.AssertNotNull(connection.RetryOptions, nameof(connection.RetryOptions)); Argument.AssertNotNullOrWhiteSpace(subscriptionPath, nameof(subscriptionPath)); connection.ThrowIfClosed(); Identifier = DiagnosticUtilities.GenerateIdentifier(subscriptionPath); _connection = connection; SubscriptionPath = subscriptionPath; InnerRuleManager = _connection.CreateTransportRuleManager( subscriptionPath: SubscriptionPath, retryPolicy: connection.RetryOptions.ToRetryPolicy()); }
/// <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); }