private static IHttpClientBuilder AddHttpClientWithPolicies <TClient, TImplementation, TClientOptions>(
IServiceCollection services,
IPolicyRegistry <string> policyRegistry,
string retryPolicyKey,
string configurationSectionName,
PolicyOptions policyOptions,
IConfiguration configuration,
string httpClientName = null)
where TClient : class
where TImplementation : class, TClient
where TClientOptions : HttpClientOptions, new()
{
var policies = services
.AddPolicies(
policyRegistry,
retryPolicyKey,
policyOptions);
if (!string.IsNullOrEmpty(httpClientName))
{
return(policies.AddNamedHttpClient <TClient, TImplementation, TClientOptions>(
configuration,
configurationSectionName,
retryPolicyKey,
httpClientName));
}
return(policies.AddUnnamedHttpClient <TClient, TImplementation, TClientOptions>(
configuration,
configurationSectionName,
retryPolicyKey));
}
public static IServiceCollection AddPolicies(
this IServiceCollection services,
IPolicyRegistry <string> policyRegistry,
string retryPolicyKey,
PolicyOptions policyOptions)
{
if (policyRegistry == null || policyOptions == null)
{
return(services);
}
policyRegistry.Add(
retryPolicyKey,
HttpPolicyExtensions
.HandleTransientHttpError()
.OrResult(msg =>
msg.StatusCode == System.Net.HttpStatusCode.TooManyRequests)
.OrResult(msg => msg?.Headers?.RetryAfter != null)
.WaitAndRetryAsync(
policyOptions.HttpRetry.Count,
retryAttempt =>
TimeSpan.FromMilliseconds(Math.Pow(policyOptions.HttpRetry.BackoffPower, retryAttempt)
* policyOptions.HttpRetry.BackOffBaseMilliseconds)));
return(services);
}
public static IServiceCollection AddPolicies(
this IServiceCollection services,
IPolicyRegistry <string> policyRegistry,
string keyPrefix,
PolicyOptions policyOptions)
{
_ = policyOptions ?? throw new ArgumentNullException(nameof(policyOptions));
policyRegistry?.Add(
$"{keyPrefix}_{nameof(PolicyOptions.HttpRetry)}",
HttpPolicyExtensions
.HandleTransientHttpError()
.OrResult(msg => msg.StatusCode == System.Net.HttpStatusCode.TooManyRequests)
.OrResult(r => r?.Headers?.RetryAfter != null)
.WaitAndRetryAsync(
policyOptions.HttpRetry.Count,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(policyOptions.HttpRetry.BackoffPower, retryAttempt))));
policyRegistry?.Add(
$"{keyPrefix}_{nameof(PolicyOptions.HttpCircuitBreaker)}",
HttpPolicyExtensions
.HandleTransientHttpError()
.CircuitBreakerAsync(
handledEventsAllowedBeforeBreaking: policyOptions.HttpCircuitBreaker.ExceptionsAllowedBeforeBreaking,
durationOfBreak: policyOptions.HttpCircuitBreaker.DurationOfBreak));
return(services);
}
public static IServiceCollection AddPolicies(
this IServiceCollection services,
IPolicyRegistry <string> policyRegistry,
string keyPrefix,
PolicyOptions policyOptions)
{
if (policyOptions != null)
{
policyRegistry?.Add(
$"{keyPrefix}_{nameof(PolicyOptions.HttpRetry)}",
HttpPolicyExtensions
.HandleTransientHttpError()
.WaitAndRetryAsync(
policyOptions.HttpRetry.Count,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(policyOptions.HttpRetry.BackoffPower, retryAttempt))));
policyRegistry?.Add(
$"{keyPrefix}_{nameof(PolicyOptions.HttpCircuitBreaker)}",
HttpPolicyExtensions
.HandleTransientHttpError()
.CircuitBreakerAsync(
handledEventsAllowedBeforeBreaking: policyOptions.HttpCircuitBreaker.ExceptionsAllowedBeforeBreaking,
durationOfBreak: policyOptions.HttpCircuitBreaker.DurationOfBreak));
return(services);
}
throw new InvalidOperationException($"{nameof(policyOptions)} is null");
}
private static void AddPolicies(IPolicyRegistry <string> policyRegistry)
{
var policyOptions = new PolicyOptions()
{
HttpRetry = new RetryPolicyOptions(), HttpCircuitBreaker = new CircuitBreakerPolicyOptions()
};
policyRegistry.Add(nameof(PolicyOptions.HttpRetry), HttpPolicyExtensions.HandleTransientHttpError().WaitAndRetryAsync(policyOptions.HttpRetry.Count, retryAttempt => TimeSpan.FromSeconds(Math.Pow(policyOptions.HttpRetry.BackoffPower, retryAttempt))));
policyRegistry.Add(nameof(PolicyOptions.HttpCircuitBreaker), HttpPolicyExtensions.HandleTransientHttpError().CircuitBreakerAsync(policyOptions.HttpCircuitBreaker.ExceptionsAllowedBeforeBreaking, policyOptions.HttpCircuitBreaker.DurationOfBreak));
}
private void GetCurrentStatus()
{
var status = GetNoUpdateStatus();
if (status == PolicyEnableUpdate)
{
status = GetAuOptionStatus();
}
SelectedPolicyOption = PolicyOptions.FirstOrDefault(x => x.Key == status);
}
public static void AddRetryPolicy(this IServiceCollection services, PolicyOptions options)
{
ISyncPolicy waitAndRetryPolicy = Policy
.Handle <Exception>()
.WaitAndRetry(options.NumberOfRetry, (counter, time) =>
{
return(TimeSpan.FromSeconds(5 + counter / 3));
});
services.AddSingleton(waitAndRetryPolicy);
}
private static void AddApplicationClientHttp(
this IServiceCollection services,
IConfiguration configuration,
PolicyOptions policyOptions,
IPolicyRegistry <string> policyRegistry)
{
var registeredUrls = GetRegisteredUrls(services);
services.AddSingleton <IRegisteredUrls>(registeredUrls);
foreach (var registeredUrl in registeredUrls.GetAll())
{
AddHttpClientWithPolicies <IUriSpecifcHttpClientFactory, UriSpecifcHttpClientFactory, ApplicationClientOptions>(
services,
policyRegistry,
$"{registeredUrl}_{nameof(ApplicationClientOptions)}_{nameof(PolicyOptions.HttpRetry)}",
nameof(ApplicationClientOptions),
policyOptions,
configuration,
$"{registeredUrl}_{nameof(UriSpecifcHttpClientFactory)}")
.AddHttpMessageHandler <CompositeSessionIdDelegatingHandler>()
.AddHttpMessageHandler <CookieDelegatingHandler>();
}
}
public BaseClient(IOptions <PolicyOptions> policyOptions, string baseUrl)
{
_baseUrl = baseUrl;
_restClient = new RestClient(_baseUrl);
_policyOptions = policyOptions.Value;
}
public void ConfigureServices(IServiceCollection services)
{
// Options
PolicyOptions policyOptions = new PolicyOptions();
_configuration.GetSection(nameof(PolicyOptions)).Bind(policyOptions);
services
.AddOptions()
.Configure <JwtAuthenticationOptions>(options => _configuration.GetSection(nameof(JwtAuthenticationOptions)).Bind(options))
.Configure <PolicyOptions>(options => options.Policies = policyOptions.Policies);
// Dependencies
services
.AddSingleton <IPostConfigureOptions <JwtBearerOptions>, ConfigureJwtBearerOptions>()
.AddSingleton <ISigningCredentialsBuilder, SigningCredentialsBuilder>()
.AddSingleton <ITranslationStringService, TranslationStringService>();
// Security
services
.AddAuthorization(options =>
{
foreach (var policyOption in policyOptions.Policies)
{
options.AddPolicy(policyOption.Name, policy =>
{
if (policyOption.Claims != null)
{
foreach (var claim in policyOption.Claims)
{
policy.RequireClaim(claim.Type, claim.AllowValues);
}
}
if (policyOption.Roles != null)
{
policy.RequireRole(policyOption.Roles.Select(role => role.Name));
}
});
}
})
.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
options.Events = new JwtBearerEvents
{
OnAuthenticationFailed = context =>
{
Console.WriteLine("OnAuthenticationFailed: " +
context.Exception.Message);
return(Task.CompletedTask);
},
OnTokenValidated = context =>
{
Console.WriteLine("OnTokenValidated: " +
context.SecurityToken);
return(Task.CompletedTask);
}
};
});
services
.AddControllers()
.AddFluentValidation(options =>
{
options.RegisterValidatorsFromAssembly(Assembly.GetExecutingAssembly());
});
}
