public DataService(SettingsService settingsService, CacheService cacheService)
{
_settingsService = settingsService;
_cacheService = cacheService;
// Connection limit
ServicePointManager.DefaultConnectionLimit = 999;
// Client
var handler = new HttpClientHandler();
if (handler.SupportsAutomaticDecompression)
{
handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
}
handler.UseCookies = false;
_httpClient = new HttpClient(handler, true);
_httpClient.DefaultRequestHeaders.Add("User-Agent", "osu!helper (github.com/Tyrrrz/OsuHelper)");
// Rate limiting
_requestRateSemaphore = new SemaphoreSlim(1, 1);
_lastRequestDateTime = DateTime.MinValue;
// Request retry policy
// (osu web server is inconsistent)
_requestRetryPolicy = Retry.Create()
.Catch <HttpErrorStatusCodeException>(false, ex => (int)ex.StatusCode >= 500)
.Catch <HttpRequestException>(false, ex => ex.InnerException is IOException)
.WithMaxTryCount(20);
}
private async Task Fetch <TCached>(IRetry retry, Func <Uri, byte[], TCached> factory, WebResponse webResponse, CancellationToken cancellationToken) where TCached : class
{
label_12:
HttpWebRequest request = this.CreateRequest();
using (HttpWebResponse response = await this._webReader.SendAsync(request, true, cancellationToken, webResponse).ConfigureAwait(false))
{
int statusCode = (int)response.StatusCode;
if (statusCode >= 200 && statusCode < 300)
{
this._firstRequestCompleted = true;
Func <Uri, byte[], TCached> func1 = factory;
Uri responseUri = response.ResponseUri;
Func <Uri, byte[], TCached> func2 = func1;
HttpWebRequestWebCache webRequestWebCache = this;
byte[] numArray = await this.FetchObject(response, cancellationToken).ConfigureAwait(false);
// ISSUE: variable of a boxed type
var local = (object)func2(responseUri, numArray);
webRequestWebCache._cachedObject = (object)local;
}
else if (HttpStatusCode.NotModified != response.StatusCode)
{
if (RetryPolicy.IsRetryable(response.StatusCode))
{
if (await retry.CanRetryAfterDelayAsync(cancellationToken).ConfigureAwait(false))
{
goto label_12;
}
}
this._cachedObject = (object)null;
throw new WebException("Unable to fetch");
}
}
}
public MangaHere(ILogger myLogger, IDownloader downloader, IXPathSelector selector, IRetry retry)
{
logger = myLogger;
this.downloader = downloader;
this.selector = selector;
this.retry = retry;
}
public NHentai(ILogger myLogger, IHttpDownloader downloader, IXPathSelector selector, IRetry retry)
{
Logger = myLogger;
this.downloader = downloader;
this.selector = selector;
this.retry = retry;
}
public SmtpConfiguration(ISmtpClientFactory smtpClientFactory, MailMessage emailMessage, IRetry retry)
{
this.smtpClientFactory = smtpClientFactory;
this.emailMessage = emailMessage;
this.retry = retry;
ConfigureSMTPSettings();
}
public AzureQueueManager(Func <ManagementClient> managementClient,
IConnectionManager connectionManager,
AutoDeleteOnIdleSetting autoDeleteOnIdle,
DefaultMessageTimeToLiveSetting defaultMessageTimeToLive,
DefaultTimeoutSetting defaultTimeout,
EnableDeadLetteringOnMessageExpirationSetting enableDeadLetteringOnMessageExpiration,
GlobalPrefixSetting globalPrefix,
MaxDeliveryAttemptSetting maxDeliveryAttempts,
ILogger logger,
IPathFactory pathFactory,
IRetry retry,
ISqlFilterExpressionGenerator sqlFilterExpressionGenerator,
ITypeProvider typeProvider)
{
_managementClient = managementClient;
_connectionManager = connectionManager;
_maxDeliveryAttempts = maxDeliveryAttempts;
_logger = logger;
_retry = retry;
_typeProvider = typeProvider;
_defaultMessageTimeToLive = defaultMessageTimeToLive;
_autoDeleteOnIdle = autoDeleteOnIdle;
_defaultTimeout = defaultTimeout;
_enableDeadLetteringOnMessageExpiration = enableDeadLetteringOnMessageExpiration;
_globalPrefix = globalPrefix;
_sqlFilterExpressionGenerator = sqlFilterExpressionGenerator;
_pathFactory = pathFactory;
_knownTopics = new ThreadSafeLazy <ConcurrentSet <string> >(FetchExistingTopics);
_knownSubscriptions = new ThreadSafeLazy <ConcurrentSet <string> >(FetchExistingSubscriptions);
_knownQueues = new ThreadSafeLazy <ConcurrentSet <string> >(FetchExistingQueues);
}
public static async Task AttemptAsync(
this IRetry policy,
Func <int, Task> action,
Action <Exception, int, TimeSpan> onException,
Action <Exception, int> onFinalException,
CancellationToken cancellationToken)
{
var timer = new Stopwatch();
timer.Start();
for (var attempt = 0; !cancellationToken.IsCancellationRequested; attempt++)
{
cancellationToken.ThrowIfCancellationRequested();
try {
await action(attempt).ConfigureAwait(false);
// reset attempt when successful
attempt = -1;
timer.Restart();
} catch (Exception ex) {
if (attempt == 0) // first failure
{
timer.Restart();
}
await policy.HandleErrorAndDelayAsync(onException, onFinalException, attempt, timer, ex, cancellationToken).ConfigureAwait(false);
}
}
}
public AzureQueueManager(Func<NamespaceManager> namespaceManager,
Func<MessagingFactory> messagingFactory,
AutoDeleteOnIdleSetting autoDeleteOnIdle,
DefaultMessageTimeToLiveSetting defaultMessageTimeToLive,
DefaultTimeoutSetting defaultTimeout,
EnableDeadLetteringOnMessageExpirationSetting enableDeadLetteringOnMessageExpiration,
GlobalPrefixSetting globalPrefix,
MaxDeliveryAttemptSetting maxDeliveryAttempts,
IPathFactory pathFactory,
IRetry retry,
ISqlFilterExpressionGenerator sqlFilterExpressionGenerator,
ITypeProvider typeProvider)
{
_namespaceManager = namespaceManager;
_messagingFactory = messagingFactory;
_maxDeliveryAttempts = maxDeliveryAttempts;
_retry = retry;
_typeProvider = typeProvider;
_defaultMessageTimeToLive = defaultMessageTimeToLive;
_autoDeleteOnIdle = autoDeleteOnIdle;
_defaultTimeout = defaultTimeout;
_enableDeadLetteringOnMessageExpiration = enableDeadLetteringOnMessageExpiration;
_globalPrefix = globalPrefix;
_sqlFilterExpressionGenerator = sqlFilterExpressionGenerator;
_pathFactory = pathFactory;
_knownTopics = new ThreadSafeLazy<ConcurrentSet<string>>(FetchExistingTopics);
_knownSubscriptions = new ThreadSafeLazy<ConcurrentSet<string>>(FetchExistingSubscriptions);
_knownQueues = new ThreadSafeLazy<ConcurrentSet<string>>(FetchExistingQueues);
}
public WindowsServiceBusQueueMessageSender(IBrokeredMessageFactory brokeredMessageFactory, ILogger logger, IQueueManager queueManager, IRetry retry, string queuePath)
{
_brokeredMessageFactory = brokeredMessageFactory;
_queueManager = queueManager;
_retry = retry;
_queuePath = queuePath;
_logger = logger;
}
public static Task <T> TryAsync <T>(
this IRetry policy,
Func <int, TimeSpan, Task <RetryAttempt <T> > > func,
Action <Exception, int, TimeSpan?> onRetry,
CancellationToken cancellationToken)
{
return(policy.TryAsync(func, onRetry, null, cancellationToken));
}
public static Task CallAsync(this IRetry retry, Func <Task> operation, CancellationToken cancellationToken)
{
return((Task)retry.CallAsync <int>((Func <Task <int> >)(async() =>
{
await operation().ConfigureAwait(false);
return 0;
}), cancellationToken));
}
public WindowsServiceBusTopicMessageSender(IBrokeredMessageFactory brokeredMessageFactory, ILogger logger, IQueueManager queueManager, IRetry retry, string topicPath)
{
_queueManager = queueManager;
_retry = retry;
_topicPath = topicPath;
_logger = logger;
_brokeredMessageFactory = brokeredMessageFactory;
}
/// <summary>
/// Executes an asynchronous action with retry.
/// </summary>
public static Task ExecuteAsync(this IRetry retry, Func <Task> taskFunction)
{
retry.GuardNotNull(nameof(retry));
taskFunction.GuardNotNull(nameof(taskFunction));
// Execute
return(retry.ExecuteAsync(taskFunction.ToObjectTaskFunc()));
}
/// <summary>
/// Executes an action with retry.
/// </summary>
public static void Execute(this IRetry retry, Action action)
{
retry.GuardNotNull(nameof(retry));
action.GuardNotNull(nameof(action));
// Execute
retry.Execute(action.ToObjectFunc());
}
public AzureServiceBusTopicMessageSender(IBrokeredMessageFactory brokeredMessageFactory, ILogger logger, IQueueManager queueManager, IRetry retry, string topicPath)
{
_queueManager = queueManager;
_retry = retry;
_topicPath = topicPath;
_logger = logger;
_brokeredMessageFactory = brokeredMessageFactory;
}
public AzureServiceBusQueueMessageSender(IBrokeredMessageFactory brokeredMessageFactory, ILogger logger, IQueueManager queueManager, IRetry retry, string queuePath)
{
_brokeredMessageFactory = brokeredMessageFactory;
_queueManager = queueManager;
_retry = retry;
_queuePath = queuePath;
_logger = logger;
}
public MangaFox(ILogger myLogger, IHttpDownloader downloader, IXPathSelector selector, IRetry retry, RemoteWebDriver webDriver)
{
Logger = myLogger;
this.downloader = downloader;
this.selector = selector;
this.retry = retry;
this.webDriver = webDriver;
Wait = new WebDriverWait(webDriver, TimeSpan.FromSeconds(10));
}
private async Task <JToken> GetApiResponseAsync(AuthToken token, string resource, string endpoint,
params string[] parameters)
{
// Create retry policy
IRetry retry = Retry.Create()
.Catch <HttpErrorStatusCodeException>(false, e => (int)e.StatusCode >= 500)
.Catch <HttpErrorStatusCodeException>(false, e => (int)e.StatusCode == 429)
.WithMaxTryCount(7200)
.WithDelay(TimeSpan.FromSeconds(0.5));
// Send request
return(await retry.ExecuteAsync(async() =>
{
// Create request
const string apiRoot = "https://discordapp.com/api/v6";
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, $"{apiRoot}/{resource}/{endpoint}"))
{
// Set authorization header
request.Headers.Authorization = token.Type == AuthTokenType.Bot
? new AuthenticationHeaderValue("Bot", token.Value)
: new AuthenticationHeaderValue(token.Value);
// Add parameters
foreach (string parameter in parameters)
{
string key = parameter.SubstringUntil("=");
string value = parameter.SubstringAfter("=");
// Skip empty values
if (value.IsNullOrWhiteSpace())
{
continue;
}
request.RequestUri = request.RequestUri.SetQueryParameter(key, value);
}
// Get response
using (HttpResponseMessage response = await _httpClient.SendAsync(request))
{
// Check status code
// We throw our own exception here because default one doesn't have status code
if (!response.IsSuccessStatusCode)
{
throw new HttpErrorStatusCodeException(response.StatusCode, response.ReasonPhrase);
}
// Get content
string raw = await response.Content.ReadAsStringAsync();
// Parse
return JToken.Parse(raw);
}
}
}));
}
public static Task <Uri> ParseAsync(this M3U8Parser parser, IWebReader webReader, IRetryManager retryManager, Uri playlist, CancellationToken cancellationToken)
{
IRetry retry = RetryManagerExtensions.CreateWebRetry(retryManager, 2, 250);
return(retry.CallAsync <Uri>((Func <Task <Uri> >)(() => WebReaderExtensions.ReadStreamAsync <Uri>(webReader, playlist, retry, (Func <Uri, Stream, Uri>)((actualPlaylist, stream) =>
{
M3U8ParserExtensions.Parse(parser, actualPlaylist, stream, (Encoding)null);
return actualPlaylist;
}), cancellationToken)), cancellationToken));
}
public async Task <TCached> ReadAsync <TCached>(Func <Uri, byte[], TCached> factory, CancellationToken cancellationToken, WebResponse webResponse = null) where TCached : class
{
if (null == (object)(this._cachedObject as TCached))
{
this._cachedObject = (object)null;
}
IRetry retry = RetryManagerExtensions.CreateWebRetry(this._retryManager, 2, 250);
await RetryExtensions.CallAsync(retry, (Func <Task>)(() => this.Fetch <TCached>(retry, factory, webResponse, cancellationToken)), cancellationToken).ConfigureAwait(false);
return(this._cachedObject as TCached);
}
public ResilientRequestProvider(IRetry resilience)
{
retry = resilience;
var authData = string.Format("{0}:{1}", Constants.Username, Constants.Password);
var authHeaderValue = Convert.ToBase64String(Encoding.UTF8.GetBytes(authData));
client = new HttpClient();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", authHeaderValue);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
}
public static IConnectionConfiguration CopyWith(
this IConnectionConfiguration configuration,
IRetry connectionRetry = null,
IVersionSupport versionSupport = null,
TimeSpan?requestTimeout = null,
int?readBufferSize = null,
int?writeBufferSize = null,
bool?isTcpKeepalive = null,
IEnumerable <IMembershipEncoder> encoders = null,
ISslConfiguration sslConfiguration = null,
ConnectError onDisconnected = null,
Connecting onConnecting = null,
Connecting onConnected = null,
Writing onWriting = null,
StartingBytes onWritingBytes = null,
FinishedBytes onWroteBytes = null,
WriteSuccess onWritten = null,
WriteError onWriteFailed = null,
Reading onReading = null,
StartingBytes onReadingBytes = null,
FinishedBytes onReadBytes = null,
ReadSuccess onRead = null,
ReadError onReadFailed = null,
ProduceRequestMessages onProduceRequestMessages = null)
{
return(new ConnectionConfiguration(
connectionRetry ?? configuration.ConnectionRetry,
versionSupport ?? configuration.VersionSupport,
requestTimeout ?? configuration.RequestTimeout,
readBufferSize ?? configuration.ReadBufferSize,
writeBufferSize ?? configuration.WriteBufferSize,
isTcpKeepalive ?? configuration.IsTcpKeepalive,
encoders ?? configuration.Encoders.Values,
sslConfiguration ?? configuration.SslConfiguration,
onDisconnected ?? configuration.OnDisconnected,
onConnecting ?? configuration.OnConnecting,
onConnected ?? configuration.OnConnected,
onWriting ?? configuration.OnWriting,
onWritingBytes ?? configuration.OnWritingBytes,
onWroteBytes ?? configuration.OnWroteBytes,
onWritten ?? configuration.OnWritten,
onWriteFailed ?? configuration.OnWriteFailed,
onReading ?? configuration.OnReading,
onReadingBytes ?? configuration.OnReadingBytes,
onReadBytes ?? configuration.OnReadBytes,
onRead ?? configuration.OnRead,
onReadFailed ?? configuration.OnReadFailed,
onProduceRequestMessages ?? configuration.OnProduceRequestMessages));
}
/// <summary>
/// Configuration for the tcp connection.
/// </summary>
/// <param name="connectionRetry">Retry details for (re)establishing the connection.</param>
/// <param name="versionSupport">Support for different protocol versions for Kakfa requests and responses.</param>
/// <param name="requestTimeout">The maximum time to wait for requests.</param>
/// <param name="readBufferSize">The buffer size to use for the socket, when receiving bytes.</param>
/// <param name="writeBufferSize">The buffer size to use for the socket, when sending bytes.</param>
/// <param name="isTcpKeepalive">TCP keepalive option.</param>
/// <param name="encoders">Custom Encoding support for different protocol types</param>
/// <param name="sslConfiguration">Configuration for SSL encrypted communication</param>
/// <param name="onDisconnected">Triggered when the tcp socket is disconnected.</param>
/// <param name="onConnecting">Triggered when the tcp socket is connecting.</param>
/// <param name="onConnected">Triggered after the tcp socket is successfully connected.</param>
/// <param name="onWriting">Triggered when writing to the tcp stream.</param>
/// <param name="onWritingBytes">Triggered when writing a chunk of bytes to the tcp stream.</param>
/// <param name="onWroteBytes">Triggered after successfully writing a chunk of bytes to the tcp stream.</param>
/// <param name="onWritten">Triggered after having successfully written to the tcp stream.</param>
/// <param name="onWriteFailed">Triggered after failing to write to the tcp stream.</param>
/// <param name="onReading">Triggered when starting to read a message's bytes from the tcp stream.</param>
/// <param name="onReadingBytes">Triggered when reading a chunk of bytes from the tcp stream.</param>
/// <param name="onReadBytes">Triggered after successfully reading a chunk of bytes from the tcp stream.</param>
/// <param name="onRead">Triggered after having successfully read a message's bytes from the tcp stream.</param>
/// <param name="onReadFailed">Triggered after failing to read from the tcp stream.</param>
/// <param name="onProduceRequestMessages">Triggered when encoding ProduceRequest messages.</param>
public ConnectionConfiguration(
IRetry connectionRetry = null,
IVersionSupport versionSupport = null,
TimeSpan?requestTimeout = null,
int?readBufferSize = null,
int?writeBufferSize = null,
bool?isTcpKeepalive = null,
IEnumerable <IMembershipEncoder> encoders = null,
ISslConfiguration sslConfiguration = null,
ConnectError onDisconnected = null,
Connecting onConnecting = null,
Connecting onConnected = null,
Writing onWriting = null,
StartingBytes onWritingBytes = null,
FinishedBytes onWroteBytes = null,
WriteSuccess onWritten = null,
WriteError onWriteFailed = null,
Reading onReading = null,
StartingBytes onReadingBytes = null,
FinishedBytes onReadBytes = null,
ReadSuccess onRead = null,
ReadError onReadFailed = null,
ProduceRequestMessages onProduceRequestMessages = null
)
{
ConnectionRetry = connectionRetry ?? Defaults.ConnectionRetry();
VersionSupport = versionSupport ?? Connections.VersionSupport.Kafka10;
RequestTimeout = requestTimeout ?? TimeSpan.FromSeconds(Defaults.RequestTimeoutSeconds);
ReadBufferSize = readBufferSize.GetValueOrDefault(Defaults.BufferSize);
WriteBufferSize = writeBufferSize.GetValueOrDefault(Defaults.BufferSize);
IsTcpKeepalive = isTcpKeepalive ?? Defaults.IsTcpKeepalive;
Encoders = Defaults.Encoders(encoders);
SslConfiguration = sslConfiguration;
OnDisconnected = onDisconnected;
OnConnecting = onConnecting;
OnConnected = onConnected;
OnWriting = onWriting;
OnWritingBytes = onWritingBytes;
OnWroteBytes = onWroteBytes;
OnWritten = onWritten;
OnWriteFailed = onWriteFailed;
OnReading = onReading;
OnReadingBytes = onReadingBytes;
OnReadBytes = onReadBytes;
OnRead = onRead;
OnReadFailed = onReadFailed;
OnProduceRequestMessages = onProduceRequestMessages;
}
public WindowsServiceBusTransport(ConcurrentHandlerLimitSetting concurrentHandlerLimit,
IBrokeredMessageFactory brokeredMessageFactory,
IGlobalHandlerThrottle globalHandlerThrottle,
ILogger logger,
IQueueManager queueManager,
Func <NamespaceManager> namespaceManager,
IRetry retry)
{
_queueManager = queueManager;
_namespaceManager = namespaceManager;
_retry = retry;
_brokeredMessageFactory = brokeredMessageFactory;
_globalHandlerThrottle = globalHandlerThrottle;
_concurrentHandlerLimit = concurrentHandlerLimit;
_logger = logger;
}
public WindowsServiceBusTransport(ConcurrentHandlerLimitSetting concurrentHandlerLimit,
IBrokeredMessageFactory brokeredMessageFactory,
IGlobalHandlerThrottle globalHandlerThrottle,
ILogger logger,
IQueueManager queueManager,
Func<NamespaceManager> namespaceManager,
IRetry retry)
{
_queueManager = queueManager;
_namespaceManager = namespaceManager;
_retry = retry;
_brokeredMessageFactory = brokeredMessageFactory;
_globalHandlerThrottle = globalHandlerThrottle;
_concurrentHandlerLimit = concurrentHandlerLimit;
_logger = logger;
}
public static async Task <T> TryAsync <T>(
this IRetry policy,
Func <int, TimeSpan, Task <RetryAttempt <T> > > func,
Action <Exception, int, TimeSpan?> onRetry,
Action onFailure,
CancellationToken cancellationToken)
{
var timer = new Stopwatch();
timer.Start();
for (var retryCount = 0;; retryCount++)
{
cancellationToken.ThrowIfCancellationRequested();
try {
var attempt = await func(retryCount, timer.Elapsed).ConfigureAwait(false);
if (attempt.IsSuccessful)
{
return(attempt.Value);
}
var retryDelay = policy.RetryDelay(retryCount, timer.Elapsed);
onRetry?.Invoke(null, retryCount, retryDelay);
if (attempt.ShouldRetry && retryDelay.HasValue)
{
await Task.Delay(retryDelay.Value, cancellationToken).ConfigureAwait(false);
}
else
{
onFailure?.Invoke();
return(attempt.Value);
}
} catch (Exception ex) {
var retryDelay = policy.RetryDelay(retryCount, timer.Elapsed);
onRetry?.Invoke(ex, retryCount, retryDelay);
if (retryDelay.HasValue)
{
await Task.Delay(retryDelay.Value, cancellationToken).ConfigureAwait(false);
}
else
{
onFailure?.Invoke();
throw ex.PrepareForRethrow();
}
}
}
}
public virtual async Task <ISegmentManager> CreateAsync(ISegmentManagerParameters parameters, ContentType contentType, CancellationToken cancellationToken)
{
ISegmentManager segmentManager1;
foreach (Uri uri in (IEnumerable <Uri>)parameters.Source)
{
Uri localUrl = uri;
IRetry retry = RetryManagerExtensions.CreateWebRetry(this._retryManager, 3, 333);
ISegmentManager segmentManager = await retry.CallAsync <ISegmentManager>((Func <Task <ISegmentManager> >)(async() =>
{
IWebReader webReader = this._webReaderManager.CreateReader(localUrl, ContentTypes.Pls.Kind, (IWebReader)null, ContentTypes.Pls);
ISegmentManager segmentManager2;
try
{
using (IWebStreamResponse webStreamResponse = await webReader.GetWebStreamAsync(localUrl, false, cancellationToken, (Uri)null, new long?(), new long?(), (WebResponse)null).ConfigureAwait(false))
{
if (!webStreamResponse.IsSuccessStatusCode)
{
webReader.Dispose();
segmentManager2 = (ISegmentManager)null;
}
else
{
using (Stream stream = await webStreamResponse.GetStreamAsync(cancellationToken).ConfigureAwait(false))
segmentManager2 = await this.ReadPlaylistAsync(webReader, webStreamResponse.ActualUrl, stream, cancellationToken).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
webReader.Dispose();
throw;
}
return(segmentManager2);
}), cancellationToken);
if (null != segmentManager)
{
segmentManager1 = segmentManager;
goto label_10;
}
}
segmentManager1 = (ISegmentManager)null;
label_10:
return(segmentManager1);
}
/// <summary>
/// Configuration for the tcp connection.
/// </summary>
/// <param name="tracker">Mechanism for tracking telemetry.</param>
/// <param name="connectionRetry">Retry details for (re)establishing the connection.</param>
/// <param name="versionSupport">Support for different protocol versions for Kakfa requests and responses.</param>
/// <param name="requestTimeout">The maximum time to wait for requests.</param>
/// <param name="encoders">Custom Encoding support for different protocol types</param>
public ConnectionConfiguration(ITrackEvents tracker, IRetry connectionRetry = null, IVersionSupport versionSupport = null, TimeSpan?requestTimeout = null, IEnumerable <IProtocolTypeEncoder> encoders = null)
: this(connectionRetry, versionSupport, requestTimeout, encoders, null,
tracker != null ? (ConnectError)tracker.Disconnected : null,
tracker != null ? (Connecting)tracker.Connecting : null,
tracker != null ? (Connecting)tracker.Connected : null,
tracker != null ? (Writing)tracker.WriteEnqueued : null,
tracker != null ? (Writing)tracker.Writing : null,
tracker != null ? (WriteSuccess)tracker.Written : null,
tracker != null ? (WriteError)tracker.WriteFailed : null,
tracker != null ? (Reading)tracker.Reading : null,
tracker != null ? (ReadingChunk)tracker.ReadingChunk : null,
tracker != null ? (ReadChunk)tracker.ReadChunk : null,
tracker != null ? (Read)tracker.Read : null,
tracker != null ? (ReadError)tracker.ReadFailed: null,
tracker != null ? (ProduceRequestMessages)tracker.ProduceRequestMessages : null)
{
}
public AzureServiceBusTransport(ConcurrentHandlerLimitSetting concurrentHandlerLimit,
IBrokeredMessageFactory brokeredMessageFactory,
IGlobalHandlerThrottle globalHandlerThrottle,
ILogger logger,
IQueueManager queueManager,
IRetry retry,
IDependencyResolver dependencyResolver,
ISqlFilterExpressionGenerator sqlFilterExpressionGenerator)
{
_queueManager = queueManager;
_retry = retry;
_dependencyResolver = dependencyResolver;
_sqlFilterExpressionGenerator = sqlFilterExpressionGenerator;
_brokeredMessageFactory = brokeredMessageFactory;
_globalHandlerThrottle = globalHandlerThrottle;
_concurrentHandlerLimit = concurrentHandlerLimit;
_logger = logger;
}
/// <summary>
/// Configuration for the tcp connection.
/// </summary>
/// <param name="connectionRetry">Retry details for (re)establishing the connection.</param>
/// <param name="versionSupport">Support for different protocol versions for Kakfa requests and responses.</param>
/// <param name="requestTimeout">The maximum time to wait for requests.</param>
/// <param name="encoders">Custom Encoding support for different protocol types</param>
/// <param name="sslConfiguration">Configuration for SSL encrypted communication</param>
/// <param name="onDisconnected">Triggered when the tcp socket is disconnected.</param>
/// <param name="onConnecting">Triggered when the tcp socket is connecting.</param>
/// <param name="onConnected">Triggered after the tcp socket is successfully connected.</param>
/// <param name="onWriteEnqueued">Triggered after enqueing async write task for writing to the tcp stream.</param>
/// <param name="onWriting">Triggered when writing to the tcp stream.</param>
/// <param name="onWritten">Triggered after having successfully written to the tcp stream.</param>
/// <param name="onWriteFailed">Triggered after failing to write to the tcp stream.</param>
/// <param name="onReading">Triggered when starting to read a message's bytes from the tcp stream.</param>
/// <param name="onReadingChunk">Triggered when reading a chunk of bytes from the tcp stream.</param>
/// <param name="onReadChunk">Triggered after successfully reading a chunk of bytes from the tcp stream.</param>
/// <param name="onRead">Triggered after having successfully read a message's bytes from the tcp stream.</param>
/// <param name="onReadFailed">Triggered after failing to read from the tcp stream.</param>
/// <param name="onProduceRequestMessages">Triggered when encoding ProduceRequest messages.</param>
public ConnectionConfiguration(
IRetry connectionRetry = null,
IVersionSupport versionSupport = null,
TimeSpan?requestTimeout = null,
IEnumerable <IProtocolTypeEncoder> encoders = null,
ISslConfiguration sslConfiguration = null,
ConnectError onDisconnected = null,
Connecting onConnecting = null,
Connecting onConnected = null,
Writing onWriteEnqueued = null,
Writing onWriting = null,
WriteSuccess onWritten = null,
WriteError onWriteFailed = null,
Reading onReading = null,
ReadingChunk onReadingChunk = null,
ReadChunk onReadChunk = null,
Read onRead = null,
ReadError onReadFailed = null,
ProduceRequestMessages onProduceRequestMessages = null
)
{
ConnectionRetry = connectionRetry ?? Defaults.ConnectionRetry();
VersionSupport = versionSupport ?? Connections.VersionSupport.Kafka8;
RequestTimeout = requestTimeout ?? TimeSpan.FromSeconds(Defaults.RequestTimeoutSeconds);
Encoders = encoders != null
? encoders.ToImmutableDictionary(e => e.Type)
: ImmutableDictionary <string, IProtocolTypeEncoder> .Empty;
SslConfiguration = sslConfiguration;
OnDisconnected = onDisconnected;
OnConnecting = onConnecting;
OnConnected = onConnected;
OnWriteEnqueued = onWriteEnqueued;
OnWriting = onWriting;
OnWritten = onWritten;
OnWriteFailed = onWriteFailed;
OnReading = onReading;
OnReadingChunk = onReadingChunk;
OnReadChunk = onReadChunk;
OnRead = onRead;
OnReadFailed = onReadFailed;
OnProduceRequestMessages = onProduceRequestMessages;
}
private async Task Fetch <TCached>(IRetry retry, Func <Uri, byte[], TCached> factory, WebResponse webResponse, CancellationToken cancellationToken) where TCached : class
{
while (true)
{
using (HttpRequestMessage request = this.CreateRequest())
{
using (HttpResponseMessage response = await this._webReader.SendAsync(request, HttpCompletionOption.ResponseContentRead, cancellationToken, webResponse).ConfigureAwait(false))
{
if (response.IsSuccessStatusCode)
{
this._firstRequestCompleted = true;
Func <Uri, byte[], TCached> func1 = factory;
Uri requestUri = response.RequestMessage.RequestUri;
Func <Uri, byte[], TCached> func2 = func1;
HttpClientWebCache httpClientWebCache = this;
byte[] numArray = await this.FetchObject(response).ConfigureAwait(false);
// ISSUE: variable of a boxed type
var local = (object)func2(requestUri, numArray);
httpClientWebCache._cachedObject = (object)local;
break;
}
if (HttpStatusCode.NotModified != response.StatusCode)
{
if (RetryPolicy.IsRetryable(response.StatusCode))
{
if (await retry.CanRetryAfterDelayAsync(cancellationToken).ConfigureAwait(false))
{
goto label_16;
}
}
this._cachedObject = (object)null;
response.EnsureSuccessStatusCode();
}
else
{
break;
}
}
}
label_16 :;
}
}
public AzureServiceBusTransport(ConcurrentHandlerLimitSetting concurrentHandlerLimit,
IBrokeredMessageFactory brokeredMessageFactory,
IGlobalHandlerThrottle globalHandlerThrottle,
ILogger logger,
IQueueManager queueManager,
Func<NamespaceManager> namespaceManager,
IRetry retry,
IDependencyResolver dependencyResolver,
ISqlFilterExpressionGenerator sqlFilterExpressionGenerator)
{
_queueManager = queueManager;
_namespaceManager = namespaceManager;
_retry = retry;
_dependencyResolver = dependencyResolver;
_sqlFilterExpressionGenerator = sqlFilterExpressionGenerator;
_brokeredMessageFactory = brokeredMessageFactory;
_globalHandlerThrottle = globalHandlerThrottle;
_concurrentHandlerLimit = concurrentHandlerLimit;
_logger = logger;
}
public ConsumerConfiguration(
TimeSpan?maxServerWait = null,
int?minFetchBytes = null,
int?maxFetchBytes = null,
int?maxPartitionFetchBytes = null,
int?fetchByteMultiplier = null,
TimeSpan?heartbeatTimeout = null,
TimeSpan?rebalanceTimeout = null,
IRetry coordinationRetry = null,
int batchSize = Defaults.BatchSize)
{
MaxFetchServerWait = maxServerWait;
MinFetchBytes = minFetchBytes;
MaxFetchBytes = maxFetchBytes;
FetchByteMultiplier = fetchByteMultiplier.GetValueOrDefault(Defaults.FetchByteMultiplier);
MaxPartitionFetchBytes = maxPartitionFetchBytes;
GroupHeartbeat = heartbeatTimeout ?? TimeSpan.FromSeconds(Defaults.HeartbeatSeconds);
GroupRebalanceTimeout = rebalanceTimeout ?? heartbeatTimeout ?? TimeSpan.FromSeconds(Defaults.RebalanceTimeoutSeconds);
GroupCoordinationRetry = coordinationRetry ?? Defaults.CoordinationRetry(GroupRebalanceTimeout);
BatchSize = Math.Max(1, batchSize);
}
public RedisSubscriptionReceiver(Subscription subscription,
Func<ConnectionMultiplexer> connectionMultiplexerFunc,
Func<IDatabase> databaseFunc,
ISerializer serializer,
ConcurrentHandlerLimitSetting concurrentHandlerLimit,
IGlobalHandlerThrottle globalHandlerThrottle,
ILogger logger,
IRetry retry)
: base(
subscription.SubscriptionMessagesRedisKey,
connectionMultiplexerFunc,
databaseFunc,
serializer,
concurrentHandlerLimit,
globalHandlerThrottle,
logger)
{
_subscription = subscription;
_databaseFunc = databaseFunc;
_retry = retry;
}
public RedisSubscriptionReceiver(Subscription subscription,
Func <ConnectionMultiplexer> connectionMultiplexerFunc,
Func <IDatabase> databaseFunc,
ISerializer serializer,
ConcurrentHandlerLimitSetting concurrentHandlerLimit,
IGlobalHandlerThrottle globalHandlerThrottle,
ILogger logger,
IRetry retry)
: base(
subscription.SubscriptionMessagesRedisKey,
connectionMultiplexerFunc,
databaseFunc,
serializer,
concurrentHandlerLimit,
globalHandlerThrottle,
logger)
{
_subscription = subscription;
_databaseFunc = databaseFunc;
_retry = retry;
}
public static async Task <T> AttemptAsync <T>(
this IRetry policy,
Func <int, Stopwatch, Task <RetryAttempt <T> > > action,
Action <int, TimeSpan> onRetry,
Action <int> onFinal,
Action <Exception> onException,
CancellationToken cancellationToken)
{
var timer = new Stopwatch();
timer.Start();
for (var attempt = 0;; attempt++)
{
cancellationToken.ThrowIfCancellationRequested();
try {
var response = await action(attempt, timer).ConfigureAwait(false);
if (response.IsSuccessful)
{
return(response.Value);
}
var retryDelay = policy.RetryDelay(attempt, timer.Elapsed);
if (retryDelay.HasValue)
{
onRetry?.Invoke(attempt, retryDelay.Value);
await Task.Delay(retryDelay.Value, cancellationToken).ConfigureAwait(false);
}
else
{
onFinal?.Invoke(attempt);
return(response.Value);
}
} catch (Exception ex) {
onException?.Invoke(ex);
onFinal?.Invoke(attempt);
return(default(T));
}
}
}
public void Initialization()
{
_retry = new Retry();
}
