KeplerServiceProxyFactory
Represents a class object to create Kepler-based web service proxy instances.
using Polly;
using Relativity.DataExchange.Logger;
using Relativity.Logging;
using Relativity.Services.Pipeline;
using System;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
namespace Relativity.DataExchange.Service
{
internal class KeplerServiceProxyFactory : IServiceProxyFactory, IDisposable
{
private readonly IServiceConnectionInfo serviceConnectionInfo;
private readonly ILog logger;
private readonly IAppSettings appSettings;
private Lazy<KeplerServiceFactory> serviceFactory;
private HttpClientHandler httpClientHandler;
private bool disposed;
public KeplerServiceProxyFactory(IServiceConnectionInfo connectionInfo)
: this(connectionInfo, RelativityLogger.Instance)
{
}
public KeplerServiceProxyFactory(IServiceConnectionInfo connectionInfo, ILog log)
: this(connectionInfo, log, AppSettings.Instance)
{
}
public KeplerServiceProxyFactory(IServiceConnectionInfo connectionInfo, IAppSettings appSettings)
: this(connectionInfo, RelativityLogger.Instance, appSettings)
{
}
public KeplerServiceProxyFactory(IServiceConnectionInfo connectionInfo, ILog log, IAppSettings appSettings)
{
serviceConnectionInfo = connectionInfo.ThrowIfNull("connectionInfo");
serviceFactory = new Lazy<KeplerServiceFactory>((Func<KeplerServiceFactory>)CreateServiceFactory);
logger = log;
this.appSettings = appSettings;
}
public void Dispose()
{
Dispose(true);
}
public TProxy CreateProxyInstance<TProxy>() where TProxy : class, IDisposable
{
ServicePointManager.SecurityProtocol |= (SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12);
if (serviceConnectionInfo.RefreshCredentials())
serviceFactory = new Lazy<KeplerServiceFactory>((Func<KeplerServiceFactory>)CreateServiceFactory);
return serviceFactory.Value.GetClient<TProxy>();
}
public void UpdateCredentials(NetworkCredential credential)
{
serviceConnectionInfo.UpdateCredentials(credential);
serviceFactory = new Lazy<KeplerServiceFactory>((Func<KeplerServiceFactory>)CreateServiceFactory);
}
public Task<string> ExecutePostAsync(string endpointAddress, string body)
{
RestClient restClient = new RestClient(new RelativityInstanceInfo {
Credentials = serviceConnectionInfo.NetworkCredential,
CookieContainer = new CookieContainer(),
WebApiServiceUrl = new Uri(AppSettings.Instance.WebApiServiceUrl)
}, logger, (double)appSettings.HttpTimeoutSeconds, appSettings.HttpErrorNumberOfRetries);
using (CancellationTokenSource cancellationTokenSource = new CancellationTokenSource())
return restClient.RequestPostStringAsync(endpointAddress, body, (int retryAttempt) => TimeSpan.FromSeconds((double)appSettings.HttpErrorWaitTimeInSeconds), delegate(Exception exception, TimeSpan timespan, Context context) {
logger.LogError(exception, "Retry - {Timespan} - Failed to call Relativity endpoint.", new object[1] {
timespan
});
}, (HttpStatusCode code) => "query Relativity endpoint ", (HttpStatusCode code) => "Error while calling Relativity endpoint.", cancellationTokenSource.Token);
}
private KeplerServiceFactory CreateServiceFactory()
{
return new KeplerServiceFactory(new KeplerServiceFactorySettings(new Uri(serviceConnectionInfo.WebServiceBaseUrl, "/Relativity.Rest/api"), serviceConnectionInfo.Credentials.GetAuthenticationHeaderValue(), (WireProtocolVersion?)1, (HttpMessageHandler)httpClientHandler));
}
private void Dispose(bool disposing)
{
if (disposing && !disposed) {
if (httpClientHandler != null) {
httpClientHandler.Dispose();
httpClientHandler = null;
}
disposed = true;
}
}
}
}