/// <summary> /// Creates a session receiver which can be used to interact with all messages with the same sessionId. /// </summary> /// /// <param name="entityPath">The name of the specific queue to associate the receiver with.</param> /// <param name="connection">The <see cref="ServiceBusConnection" /> connection to use for communication with the Service Bus service.</param> /// <param name="plugins">The set of plugins to apply to incoming messages.</param> /// <param name="options">A set of options to apply when configuring the receiver.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// ///<returns>Returns a new instance of the <see cref="ServiceBusSessionReceiver"/> class.</returns> internal static async Task <ServiceBusSessionReceiver> CreateSessionReceiverAsync( string entityPath, ServiceBusConnection connection, IList <ServiceBusPlugin> plugins, ServiceBusSessionReceiverOptions options = default, CancellationToken cancellationToken = default) { var receiver = new ServiceBusSessionReceiver( connection: connection, entityPath: entityPath, plugins: plugins, options: options); try { await receiver.OpenLinkAsync(cancellationToken).ConfigureAwait(false); } catch (Exception ex) { receiver.Logger.ClientCreateException(typeof(ServiceBusSessionReceiver), receiver.FullyQualifiedNamespace, entityPath, ex); throw; } receiver.Logger.ClientCreateComplete(typeof(ServiceBusSessionReceiver), receiver.Identifier); return(receiver); }
public SessionReceiverManager( ServiceBusConnection connection, string fullyQualifiedNamespace, string entityPath, string identifier, string sessionId, ServiceBusProcessorOptions processorOptions, Func <ProcessSessionEventArgs, Task> sessionInitHandler, Func <ProcessSessionEventArgs, Task> sessionCloseHandler, Func <ProcessSessionMessageEventArgs, Task> messageHandler, Func <ProcessErrorEventArgs, Task> errorHandler, SemaphoreSlim concurrentAcceptSessionsSemaphore, EntityScopeFactory scopeFactory, IList <ServiceBusPlugin> plugins) : base(connection, fullyQualifiedNamespace, entityPath, identifier, processorOptions, default, errorHandler, scopeFactory, plugins) { _sessionInitHandler = sessionInitHandler; _sessionCloseHandler = sessionCloseHandler; _messageHandler = messageHandler; _concurrentAcceptSessionsSemaphore = concurrentAcceptSessionsSemaphore; _sessionReceiverOptions = new ServiceBusSessionReceiverOptions { ReceiveMode = _processorOptions.ReceiveMode, PrefetchCount = _processorOptions.PrefetchCount, SessionId = sessionId }; }
/// <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="options">A set of options to apply when configuring the consumer.</param> internal ServiceBusSessionReceiver( ServiceBusConnection connection, string entityPath, ServiceBusSessionReceiverOptions options) : base(connection, entityPath, true, options?.ToReceiverOptions(), options?.SessionId) { }
/// <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="plugins">The set of 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 receive from.</param> internal ServiceBusSessionReceiver( ServiceBusConnection connection, string entityPath, IList <ServiceBusPlugin> plugins, ServiceBusSessionReceiverOptions options, string sessionId = default) : base(connection, entityPath, true, plugins, options?.ToReceiverOptions(), sessionId) { }
/// <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="options">A set of options to apply when configuring the consumer.</param> /// <param name="cancellationToken">The cancellation token to use when opening the receiver link.</param> /// <param name="sessionId">An optional session Id to receive from.</param> /// <param name="isProcessor"></param> internal ServiceBusSessionReceiver( ServiceBusConnection connection, string entityPath, ServiceBusSessionReceiverOptions options, CancellationToken cancellationToken, string sessionId = default, bool isProcessor = false) : base(connection, entityPath, true, options?.ToReceiverOptions(), sessionId, isProcessor, cancellationToken) { _connection = connection; }
/// <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="plugins">The set of plugins to apply to incoming messages.</param> /// <param name="options">A set of options to apply when configuring the consumer.</param> /// <param name="cancellationToken">The cancellation token to use when opening the receiver link.</param> /// <param name="sessionId">An optional session Id to receive from.</param> internal ServiceBusSessionReceiver( ServiceBusConnection connection, string entityPath, IList <ServiceBusPlugin> plugins, ServiceBusSessionReceiverOptions options, CancellationToken cancellationToken, string sessionId = default) : base(connection, entityPath, true, plugins, options?.ToReceiverOptions(), sessionId, cancellationToken) { _connection = connection; }
/// <summary> /// Creates a <see cref="ServiceBusSessionReceiver"/> instance that can be used for receiving /// and settling messages from a specific session-enabled queue. It uses <see cref="ReceiveMode"/> to specify /// how messages are received. Defaults to PeekLock mode. The <see cref="ReceiveMode"/> is set in <see cref="ServiceBusReceiverOptions"/>. /// </summary> /// /// <param name="queueName">The session-enabled queue to create a <see cref="ServiceBusSessionReceiver"/> for.</param> /// <param name="options">The set of <see cref="ServiceBusReceiverOptions"/> to use for configuring the /// <see cref="ServiceBusSessionReceiver"/>.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <remarks>Because this is establishing a session lock, this method performs a service call. If the /// sessionId parameter is not specified, and there are no available messages in the queue, this will /// throw a <see cref="ServiceBusException"/> with <see cref="ServiceBusException.Reason"/> of <see cref="ServiceBusException.FailureReason.ServiceTimeout"/>. /// </remarks> /// /// <returns>A <see cref="ServiceBusSessionReceiver"/> scoped to the specified queue and a specific session.</returns> public virtual async Task <ServiceBusSessionReceiver> CreateSessionReceiverAsync( string queueName, ServiceBusSessionReceiverOptions options = default, CancellationToken cancellationToken = default) { ValidateEntityName(queueName); return(await ServiceBusSessionReceiver.CreateSessionReceiverAsync( entityPath : queueName, connection : Connection, options : options, cancellationToken : cancellationToken).ConfigureAwait(false)); }
/// <summary> /// Creates a <see cref="ServiceBusSessionReceiver"/> instance that can be used for receiving /// and settling messages from a specific session-enabled queue. It uses <see cref="ServiceBusReceiveMode"/> to specify /// how messages are received. Defaults to PeekLock mode. The <see cref="ServiceBusReceiveMode"/> is set in <see cref="ServiceBusReceiverOptions"/>. /// </summary> /// /// <param name="queueName">The session-enabled queue to create a <see cref="ServiceBusSessionReceiver"/> for.</param> /// <param name="options">The set of <see cref="ServiceBusReceiverOptions"/> to use for configuring the /// <see cref="ServiceBusSessionReceiver"/>.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <remarks>Because this is establishing a session lock, this method performs a service call. If there are no available messages in the queue, /// this will throw a <see cref="ServiceBusException"/> with <see cref="ServiceBusException.Reason"/> of <see cref="ServiceBusFailureReason.ServiceTimeout"/>. /// </remarks> /// /// <returns>A <see cref="ServiceBusSessionReceiver"/> scoped to the specified queue and a specific session.</returns> public virtual async Task <ServiceBusSessionReceiver> AcceptNextSessionAsync( string queueName, ServiceBusSessionReceiverOptions options = default, CancellationToken cancellationToken = default) { ValidateEntityName(queueName); return(await ServiceBusSessionReceiver.CreateSessionReceiverAsync( entityPath : queueName, connection : Connection, plugins : Plugins, options : options, sessionId : default,
/// <summary> /// Creates a <see cref="ServiceBusSessionReceiver"/> instance that can be used for receiving /// and settling messages from a specific session-enabled subscription. It uses <see cref="ReceiveMode"/> to specify /// how messages are received. Defaults to PeekLock mode. The <see cref="ReceiveMode"/> is set in <see cref="ServiceBusReceiverOptions"/>. /// </summary> /// /// <param name="topicName">The topic to create a <see cref="ServiceBusSessionReceiver"/> for.</param> /// <param name="subscriptionName">The session-enabled subscription to create a <see cref="ServiceBusSessionReceiver"/> for.</param> /// <param name="options">The set of <see cref="ServiceBusReceiverOptions"/> to use for configuring the /// <see cref="ServiceBusSessionReceiver"/>.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <remarks>Because this is establishing a session lock, this method performs a service call. If the /// sessionId parameter is not specified, and there are no available messages in the queue, this will /// throw a <see cref="ServiceBusException"/> with <see cref="ServiceBusException.Reason"/> of <see cref="ServiceBusException.FailureReason.ServiceTimeout"/>. /// </remarks> /// /// <returns>A <see cref="ServiceBusSessionReceiver"/> scoped to the specified queue and a specific session.</returns> public virtual async Task <ServiceBusSessionReceiver> CreateSessionReceiverAsync( string topicName, string subscriptionName, ServiceBusSessionReceiverOptions options = default, CancellationToken cancellationToken = default) { ValidateEntityName(topicName); return(await ServiceBusSessionReceiver.CreateSessionReceiverAsync( entityPath : EntityNameFormatter.FormatSubscriptionPath(topicName, subscriptionName), connection : Connection, options : options, cancellationToken : cancellationToken).ConfigureAwait(false)); }
/// <summary> /// Creates a <see cref="ServiceBusSessionReceiver"/> instance that can be used for receiving /// and settling messages from a specific session-enabled queue. It uses <see cref="ReceiveMode"/> to specify /// how messages are received. Defaults to PeekLock mode. The <see cref="ReceiveMode"/> is set in <see cref="ServiceBusReceiverOptions"/>. /// </summary> /// /// <param name="queueName">The session-enabled queue to create a <see cref="ServiceBusSessionReceiver"/> for.</param> /// <param name="sessionId">Gets or sets a session ID to scope the <see cref="ServiceBusSessionReceiver"/> to.</param> /// <param name="options">The set of <see cref="ServiceBusReceiverOptions"/> to use for configuring the /// <see cref="ServiceBusSessionReceiver"/>.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// /// <remarks>Because this is establishing a session lock, this method performs a service call. If the /// sessionId parameter is null, and there are no available messages in the queue, this will /// throw a <see cref="ServiceBusException"/> with <see cref="ServiceBusException.Reason"/> of <see cref="ServiceBusFailureReason.ServiceTimeout"/>. /// </remarks> /// /// <returns>A <see cref="ServiceBusSessionReceiver"/> scoped to the specified queue and a specific session.</returns> public virtual async Task <ServiceBusSessionReceiver> AcceptSessionAsync( string queueName, string sessionId, ServiceBusSessionReceiverOptions options = default, CancellationToken cancellationToken = default) { ValidateEntityName(queueName); options ??= new ServiceBusSessionReceiverOptions(); options.SessionId = sessionId; return(await ServiceBusSessionReceiver.CreateSessionReceiverAsync( entityPath : queueName, connection : Connection, plugins : Plugins, options : options, cancellationToken : cancellationToken).ConfigureAwait(false)); }
public SessionReceiverManager( ServiceBusSessionProcessor sessionProcessor, string sessionId, SemaphoreSlim concurrentAcceptSessionsSemaphore, EntityScopeFactory scopeFactory, bool keepOpenOnReceiveTimeout) : base(sessionProcessor.InnerProcessor, scopeFactory) { _concurrentAcceptSessionsSemaphore = concurrentAcceptSessionsSemaphore; _sessionReceiverOptions = new ServiceBusSessionReceiverOptions { ReceiveMode = sessionProcessor.InnerProcessor.Options.ReceiveMode, PrefetchCount = sessionProcessor.InnerProcessor.Options.PrefetchCount, }; _sessionId = sessionId; _keepOpenOnReceiveTimeout = keepOpenOnReceiveTimeout; _sessionProcessor = sessionProcessor; }
/// <summary> /// Creates a session receiver which can be used to interact with all messages with the same sessionId. /// </summary> /// <param name="entityPath">The name of the specific queue to associate the receiver with.</param> /// <param name="connection">The <see cref="ServiceBusConnection" /> connection to use for communication with the Service Bus service.</param> /// <param name="plugins">The set of plugins to apply to incoming messages.</param> /// <param name="options">A set of options to apply when configuring the receiver.</param> /// <param name="sessionId">The Session Id to receive from or null to receive from the next available session.</param> /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param> /// <param name="isProcessor">True if called from the session processor.</param> /// <returns>Returns a new instance of the <see cref="ServiceBusSessionReceiver"/> class.</returns> internal static async Task <ServiceBusSessionReceiver> CreateSessionReceiverAsync( string entityPath, ServiceBusConnection connection, IList <ServiceBusPlugin> plugins, ServiceBusSessionReceiverOptions options, string sessionId, CancellationToken cancellationToken, bool isProcessor = false) { var receiver = new ServiceBusSessionReceiver( connection: connection, entityPath: entityPath, plugins: plugins, options: options, cancellationToken: cancellationToken, sessionId: sessionId, isProcessor: isProcessor); try { await receiver.OpenLinkAsync(isProcessor, cancellationToken).ConfigureAwait(false); } catch (ServiceBusException e) when(e.Reason == ServiceBusFailureReason.ServiceTimeout && isProcessor) { receiver.Logger.ProcessorAcceptSessionTimeout(receiver.FullyQualifiedNamespace, entityPath, e.ToString()); throw; } catch (TaskCanceledException exception) when(isProcessor) { receiver.Logger.ProcessorStoppingAcceptSessionCanceled(receiver.FullyQualifiedNamespace, entityPath, exception.ToString()); throw; } catch (Exception ex) { receiver.Logger.ClientCreateException(typeof(ServiceBusSessionReceiver), receiver.FullyQualifiedNamespace, entityPath, ex); throw; } receiver.Logger.ClientCreateComplete(typeof(ServiceBusSessionReceiver), receiver.Identifier); return(receiver); }
public SessionReceiverManager( ServiceBusProcessor processor, string sessionId, SemaphoreSlim concurrentAcceptSessionsSemaphore, EntityScopeFactory scopeFactory, IList <ServiceBusPlugin> plugins, int maxCallsPerSession, bool keepOpenOnReceiveTimeout) : base(processor, scopeFactory, plugins) { _concurrentAcceptSessionsSemaphore = concurrentAcceptSessionsSemaphore; _maxCallsPerSession = maxCallsPerSession; _sessionReceiverOptions = new ServiceBusSessionReceiverOptions { ReceiveMode = processor.Options.ReceiveMode, PrefetchCount = processor.Options.PrefetchCount, }; _sessionId = sessionId; _keepOpenOnReceiveTimeout = keepOpenOnReceiveTimeout; }