< Summary

Class:Azure.Messaging.ServiceBus.ServiceBusSessionProcessor
Assembly:Azure.Messaging.ServiceBus
File(s):C:\Git\azure-sdk-for-net\sdk\servicebus\Azure.Messaging.ServiceBus\src\Processor\ServiceBusSessionProcessor.cs
Covered lines:39
Uncovered lines:10
Coverable lines:49
Total lines:247
Line coverage:79.5% (39 of 49)
Covered branches:0
Total branches:0

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
get_EntityPath()-0%100%
get_Identifier()-0%100%
get_ReceiveMode()-100%100%
get_PrefetchCount()-100%100%
get_IsProcessing()-0%100%
get_AutoComplete()-100%100%
get_MaxAutoLockRenewalDuration()-100%100%
get_MaxConcurrentSessions()-100%100%
get_MaxConcurrentCallsPerSession()-100%100%
get_FullyQualifiedNamespace()-100%100%
get_MaxReceiveWaitTime()-0%100%
.ctor(...)-100%100%
.ctor()-0%100%
add_ProcessMessageAsync(...)-100%100%
remove_ProcessMessageAsync(...)-100%100%
add_ProcessErrorAsync(...)-100%100%
remove_ProcessErrorAsync(...)-100%100%
add_SessionInitializingAsync(...)-100%100%
remove_SessionInitializingAsync(...)-100%100%
add_SessionClosingAsync(...)-100%100%
remove_SessionClosingAsync(...)-100%100%
StartProcessingAsync()-100%100%
StopProcessingAsync()-0%100%
Equals(...)-0%100%
GetHashCode()-0%100%
ToString()-0%100%

File(s)

C:\Git\azure-sdk-for-net\sdk\servicebus\Azure.Messaging.ServiceBus\src\Processor\ServiceBusSessionProcessor.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Collections.Generic;
 6using System.ComponentModel;
 7using System.Diagnostics.CodeAnalysis;
 8using System.Threading;
 9using System.Threading.Tasks;
 10using Azure.Messaging.ServiceBus.Plugins;
 11
 12namespace Azure.Messaging.ServiceBus
 13{
 14    /// <summary>
 15    /// The <see cref="ServiceBusSessionProcessor"/> provides an abstraction around a set of <see cref="ServiceBusSessio
 16    /// allows using an event based model for processing received <see cref="ServiceBusReceivedMessage" />.
 17    /// It is constructed by calling <see cref="ServiceBusClient.CreateSessionProcessor(string, ServiceBusSessionProcess
 18    /// The event handler is specified with the <see cref="ProcessMessageAsync"/>
 19    /// property. The error handler is specified with the <see cref="ProcessErrorAsync"/> property.
 20    /// To start processing after the handlers have been specified, call <see cref="StartProcessingAsync"/>.
 21    /// </summary>
 22    public class ServiceBusSessionProcessor
 23    {
 24        private readonly ServiceBusProcessor _innerProcessor;
 25
 26        /// <summary>
 27        /// The path of the Service Bus entity that the processor is connected to, specific to the
 28        /// Service Bus namespace that contains it.
 29        /// </summary>
 030        public string EntityPath => _innerProcessor.EntityPath;
 31
 32        /// <summary>
 33        /// Gets the ID to identify this client. This can be used to correlate logs and exceptions.
 34        /// </summary>
 35        /// <remarks>Every new client has a unique ID.</remarks>
 036        internal string Identifier => _innerProcessor.Identifier;
 37
 38        /// <summary>
 39        /// The <see cref="ReceiveMode"/> used to specify how messages are received. Defaults to PeekLock mode.
 40        /// </summary>
 241        public ReceiveMode ReceiveMode => _innerProcessor.ReceiveMode;
 42
 43        /// <summary>
 44        /// Gets the number of messages that will be eagerly requested from Queues or Subscriptions and queued locally w
 45        /// whether a processing is currently active, intended to help maximize throughput by allowing the receiver to r
 46        /// from a local cache rather than waiting on a service request.
 47        /// </summary>
 248        public int PrefetchCount => _innerProcessor.PrefetchCount;
 49
 50        /// <summary>
 51        /// Indicates whether or not this <see cref="ServiceBusSessionProcessor"/> is currently processing messages.
 52        /// </summary>
 53        ///
 54        /// <value>
 55        /// <c>true</c> if the client is processing messages; otherwise, <c>false</c>.
 56        /// </value>
 057        public bool IsProcessing => _innerProcessor.IsProcessing;
 58
 59        /// <summary>Gets a value that indicates whether the <see cref="ServiceBusSessionProcessor"/> should automatical
 60        /// complete messages after the event handler has completed processing. If the event handler
 61        /// triggers an exception, the message will not be automatically completed.</summary>
 62        ///
 63        /// <value>true if the message will be completed automatically on successful execution of the operation; otherwi
 264        public bool AutoComplete => _innerProcessor.AutoComplete;
 65
 66        /// <summary>
 67        /// Gets the maximum duration within which the lock will be renewed automatically. This
 68        /// value should be greater than the longest message lock duration; for example, the LockDuration Property.
 69        /// </summary>
 70        ///
 71        /// <value>The maximum duration during which locks are automatically renewed.</value>
 72        ///
 73        /// <remarks>The message renew can continue for sometime in the background
 74        /// after completion of message and result in a few false MessageLockLostExceptions temporarily.</remarks>
 275        public TimeSpan MaxAutoLockRenewalDuration => _innerProcessor.MaxAutoLockRenewalDuration;
 76
 77        /// <summary>Gets the maximum number of sessions that will be processed concurrently by the processor.
 78        /// The default value is 8.</summary>
 279        public int MaxConcurrentSessions => _innerProcessor.MaxConcurrentSessions;
 80
 81        /// <summary>Gets the maximum number of calls to the callback the processor will initiate per session.
 82        /// Thus the total number of callbacks will be equal to MaxConcurrentSessions * MaxConcurrentCallsPerSession.
 83        /// The default value is 1.</summary>
 284        public int MaxConcurrentCallsPerSession => _innerProcessor.MaxConcurrentCallsPerSession;
 85
 86        /// <summary>
 87        /// The fully qualified Service Bus namespace that the receiver is associated with.  This is likely
 88        /// to be similar to <c>{yournamespace}.servicebus.windows.net</c>.
 89        /// </summary>
 290        public string FullyQualifiedNamespace => _innerProcessor.FullyQualifiedNamespace;
 91
 92        /// <summary>
 93        /// The maximum amount of time to wait for each Receive call using the processor's underlying receiver. If not s
 94        /// </summary>
 095        public TimeSpan? MaxReceiveWaitTime => _innerProcessor.MaxReceiveWaitTime;
 96
 1497        internal ServiceBusSessionProcessor(
 1498            ServiceBusConnection connection,
 1499            string entityPath,
 14100            IList<ServiceBusPlugin> plugins,
 14101            ServiceBusSessionProcessorOptions options)
 102        {
 14103            _innerProcessor = new ServiceBusProcessor(
 14104                connection,
 14105                entityPath,
 14106                true,
 14107                plugins,
 14108                options.ToProcessorOptions(),
 14109                options.SessionIds,
 14110                options.MaxConcurrentSessions,
 14111                options.MaxConcurrentCallsPerSession);
 14112        }
 113
 114        /// <summary>
 115        /// Initializes a new instance of the <see cref="ServiceBusSessionProcessor"/> class for mocking.
 116        /// </summary>
 0117        protected ServiceBusSessionProcessor()
 118        {
 0119        }
 120
 121        /// <summary>
 122        /// The event responsible for processing messages received from the Queue or Subscription. Implementation
 123        /// is mandatory.
 124        /// </summary>
 125        ///
 126        [SuppressMessage("Usage", "AZC0002:Ensure all service methods take an optional CancellationToken parameter.", Ju
 127        [SuppressMessage("Usage", "AZC0003:DO make service methods virtual.", Justification = "This member follows the s
 128        public event Func<ProcessSessionMessageEventArgs, Task> ProcessMessageAsync
 129        {
 130            add
 131            {
 14132                _innerProcessor.ProcessSessionMessageAsync += value;
 133
 10134            }
 135
 136            remove
 137            {
 6138                _innerProcessor.ProcessSessionMessageAsync -= value;
 2139            }
 140        }
 141
 142        /// <summary>
 143        /// The event responsible for processing unhandled exceptions thrown while this processor is running.
 144        /// Implementation is mandatory.
 145        /// </summary>
 146        ///
 147        [SuppressMessage("Usage", "AZC0002:Ensure all service methods take an optional CancellationToken parameter.", Ju
 148        [SuppressMessage("Usage", "AZC0003:DO make service methods virtual.", Justification = "This member follows the s
 149        public event Func<ProcessErrorEventArgs, Task> ProcessErrorAsync
 150        {
 151            add
 152            {
 12153                _innerProcessor.ProcessErrorAsync += value;
 8154            }
 155
 156            remove
 157            {
 6158                _innerProcessor.ProcessErrorAsync -= value;
 2159            }
 160        }
 161
 162        /// <summary>
 163        /// Optional event that can be set to be notified when a new session is about to be processed.
 164        /// </summary>
 165        [SuppressMessage("Usage", "AZC0002:Ensure all service methods take an optional CancellationToken parameter.", Ju
 166        [SuppressMessage("Usage", "AZC0003:DO make service methods virtual.", Justification = "This member follows the s
 167        public event Func<ProcessSessionEventArgs, Task> SessionInitializingAsync
 168        {
 169            add
 170            {
 12171                _innerProcessor.SessionInitializingAsync += value;
 172
 8173            }
 174
 175            remove
 176            {
 6177                _innerProcessor.SessionInitializingAsync -= value;
 2178            }
 179        }
 180
 181        /// <summary>
 182        /// Optional event that can be set to be notified when a session is about to be closed for processing.
 183        /// This means that the most recent <see cref="ServiceBusReceiver.ReceiveMessageAsync"/> call timed out,
 184        /// so there are currently no messages available to be received for the session.
 185        /// </summary>
 186        [SuppressMessage("Usage", "AZC0002:Ensure all service methods take an optional CancellationToken parameter.", Ju
 187        [SuppressMessage("Usage", "AZC0003:DO make service methods virtual.", Justification = "This member follows the s
 188        public event Func<ProcessSessionEventArgs, Task> SessionClosingAsync
 189        {
 190            add
 191            {
 12192                _innerProcessor.SessionClosingAsync += value;
 8193            }
 194
 195            remove
 196            {
 6197                _innerProcessor.SessionClosingAsync -= value;
 2198            }
 199        }
 200
 201        /// <summary>
 202        /// Signals the <see cref="ServiceBusSessionProcessor" /> to begin processing messages. Should this method be ca
 203        /// is running, no action is taken.
 204        /// </summary>
 205        ///
 206        /// <param name="cancellationToken">A <see cref="CancellationToken"/> instance to signal the request to cancel t
 207        public virtual async Task StartProcessingAsync(CancellationToken cancellationToken = default) =>
 4208            await _innerProcessor.StartProcessingAsync(cancellationToken).ConfigureAwait(false);
 209
 210        /// <summary>
 211        /// Signals the <see cref="ServiceBusSessionProcessor" /> to stop processing events. Should this method be calle
 212        /// is not running, no action is taken.
 213        /// </summary>
 214        ///
 215        /// <param name="cancellationToken">A <see cref="CancellationToken"/> instance to signal the request to cancel t
 216        public virtual async Task StopProcessingAsync(CancellationToken cancellationToken = default) =>
 0217            await _innerProcessor.StopProcessingAsync(cancellationToken).ConfigureAwait(false);
 218
 219        /// <summary>
 220        ///   Determines whether the specified <see cref="System.Object" /> is equal to this instance.
 221        /// </summary>
 222        ///
 223        /// <param name="obj">The <see cref="System.Object" /> to compare with this instance.</param>
 224        ///
 225        /// <returns><c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>
 226        [EditorBrowsable(EditorBrowsableState.Never)]
 0227        public override bool Equals(object obj) => base.Equals(obj);
 228
 229        /// <summary>
 230        /// Returns a hash code for this instance.
 231        /// </summary>
 232        ///
 233        /// <returns>A hash code for this instance, suitable for use in hashing algorithms and data structures like a ha
 234        ///
 235        [EditorBrowsable(EditorBrowsableState.Never)]
 0236        public override int GetHashCode() => base.GetHashCode();
 237
 238        /// <summary>
 239        /// Converts the instance to string representation.
 240        /// </summary>
 241        ///
 242        /// <returns>A <see cref="System.String" /> that represents this instance.</returns>
 243        ///
 244        [EditorBrowsable(EditorBrowsableState.Never)]
 0245        public override string ToString() => base.ToString();
 246    }
 247}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:43 PM
GitHub | www.palmmedia.de

Methods/Properties

get_EntityPath()
get_Identifier()
get_ReceiveMode()
get_PrefetchCount()
get_IsProcessing()
get_AutoComplete()
get_MaxAutoLockRenewalDuration()
get_MaxConcurrentSessions()
get_MaxConcurrentCallsPerSession()
get_FullyQualifiedNamespace()
get_MaxReceiveWaitTime()
.ctor(...)
.ctor()
add_ProcessMessageAsync(...)
remove_ProcessMessageAsync(...)
add_ProcessErrorAsync(...)
remove_ProcessErrorAsync(...)
add_SessionInitializingAsync(...)
remove_SessionInitializingAsync(...)
add_SessionClosingAsync(...)
remove_SessionClosingAsync(...)
StartProcessingAsync()
StopProcessingAsync()
Equals(...)
GetHashCode()
ToString()