/// <summary>
/// Sends provided message.
/// </summary>
/// <typeparam name="TResult">Assumed type of response.</typeparam>
/// <param name="message">Request message instance.</param>
/// <returns>Responce object.</returns>
private async Task <TResult> SendAsync <TResult>(HttpRequestMessage message)
where TResult : class, new()
{
using var response = await _httpClient.SendAsync(message, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
return(await ProcessResponseAsync <TResult>(response).ConfigureAwait(false));
}
public async Task <ResponseContentModel> ReturnContent(HttpRequestMessage request,
Type expectedType,
Type expectedErrorType = null)
{
var successContentService = _contentServiceFactory.GetService(expectedType);
var failureContentService = _contentServiceFactory.GetService(expectedErrorType);
var startTime = _dateTime.Now;
using (var response = await _client.SendAsync(request))
{
var completeTime = _dateTime.Now;
object content = null;
if (response.IsSuccessStatusCode && successContentService != null)
{
content = await successContentService.ReadContent(response);
}
if (!response.IsSuccessStatusCode && failureContentService != null)
{
content = await failureContentService.ReadContent(response);
}
return(new ResponseContentModel(completeTime - startTime,
response.StatusCode,
startTime,
content));
}
}
/// <summary>
/// Perform the WebDAV call and fire the callback when finished.
/// </summary>
/// <param name="uri"></param>
/// <param name="method"></param>
/// <param name="headers"></param>
/// <param name="content"></param>
private async Task <HttpResponseMessage> HttpRequest(Uri uri, HttpMethod method, IDictionary <string, string> headers = null, byte[] content = null)
{
using (var request = new HttpRequestMessage(method, uri))
{
request.Headers.Connection.Add("Keep-Alive");
if (!string.IsNullOrWhiteSpace(UserAgent))
{
request.Headers.UserAgent.Add(new ProductInfoHeaderValue(UserAgent, UserAgentVersion));
}
else
{
request.Headers.UserAgent.Add(new ProductInfoHeaderValue("WebDAVClient", m_assemblyVersion));
}
if (headers != null)
{
foreach (string key in headers.Keys)
{
request.Headers.Add(key, headers[key]);
}
}
// Need to send along content?
if (content != null)
{
request.Content = new ByteArrayContent(content);
request.Content.Headers.ContentType = new MediaTypeHeaderValue("text/xml");
}
return(await m_httpClientWrapper.SendAsync(request, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false));
}
}
public async Task <HttpResponseMessage> SendAsync(HttpClient client, HttpRequestMessage request, CancellationToken cancellationToken)
{
foreach (var filter in filters)
{
await filter.Filter(request, cancellationToken);
}
var rsp = await clientWrapper.SendAsync(client, request, cancellationToken);
try
{
foreach (var filter in filters)
{
await filter.Filter(rsp, cancellationToken);
}
}
catch
{
rsp.Dispose();
throw;
}
return(rsp);
}
public async Task <HttpResponseMessage> GetAsync(Url url)
{
url = ValidateUrl(url);
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = url.ToUri()
};
var response = await _httpClient
.SendAsync(request)
.ConfigureAwait(false);
return(response);
}
private async Task <HttpResponseMessage> SendRequestAndCheckStatus(IHttpClientWrapper clientWrapper, HttpRequestMessage requestMessage)
{
var response = await clientWrapper.SendAsync(requestMessage);
await CheckResponseStatus(response);
return(response);
}
public async Task <TResult> SendAsync <TResult>(HttpRequest <TResult> httpRequest, CancellationToken cancellationToken)
{
return((TResult)(await this.func(
async(innerHttpRequest, innerCt) =>
{
var result = await httpClientWrapper.SendAsync(ConvertHttpRequest <object, TResult>(innerHttpRequest), innerCt).ConfigureAwait(false);
return result;
},
ConvertHttpRequest <TResult, object>(httpRequest),
typeof(TResult),
cancellationToken).ConfigureAwait(false)));
}
private async Task <string> RequestApiAsync(string apiKey, ApiFunction function,
IDictionary <string, string>?query)
{
var request = ComposeHttpRequest(_apiKey, function, query);
var response = await _httpClient.SendAsync(request)
.ConfigureAwait(false);
var jsonString = await response.Content.ReadAsStringAsync()
.ConfigureAwait(false);
return(jsonString);
}
private async Task <HttpResponseMessage> SendRequestAsync(HttpMethod method, string url, object data = null, string customToken = null)
{
using (var requestMessage = new HttpRequestMessage(method, url))
{
SetAutorizationHeader(customToken, requestMessage);
await SetContent(data, requestMessage);
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
return(response);
}
}
private async Task <HttpResponseMessage> SendAsync(
HttpMethod method,
string path,
IDictionary <string, string> query,
HttpContent content,
IDictionary <string, string> headers,
CancellationToken cancellationToken)
{
string dateTimeReference = _dateTime.Now.ToString("R");
headers.Add("x-ms-date", dateTimeReference);
headers.Add("x-ms-version", ApiVersion);
string canonicalisedHeaders = CreateCanonicalisedHeaders(headers);
string canonicalisedResources = CreateCanonicalisedResources(query);
string queryString = CreateQueryString(query);
var uri = new Uri($"{_baseUri}/{path}?{queryString}");
string signature = GenerateSignature(method.Method,
contentLength: content.Headers.ContentLength > 0 ? content.Headers.ContentLength.ToString() : "",
range: headers.ContainsKey("range") ? headers["range"] : "",
canonicalisedHeaders: canonicalisedHeaders,
canonicalisedResource: $"/{_storageAccountName}{uri.AbsolutePath}\n{canonicalisedResources}"
);
var request = new HttpRequestMessage
{
Method = method,
Content = content,
RequestUri = uri,
Headers = { Authorization = await _authorisation.AuthoriseAsync(_storageAccountName, signature) }
};
headers.ToList().ForEach(x => request.Headers.Add(x.Key, x.Value));
HttpResponseMessage result = await _httpClient.SendAsync(request, cancellationToken);
try
{
result.EnsureSuccessStatusCode();
}
catch (Exception e)
{
throw new DataLakeGen2Exception("Exception occurred during call to Data Lake Gen 2 Rest API.", e)
{
StatusCode = result.StatusCode
};
}
return(result);
}
private async Task <HttpResponseMessage> SendRequestAsync(HttpMethod method, string url, object data = null, string customToken = null, string username = null, string password = null, FormUrlEncodedContent encodedContent = null)
{
using (var requestMessage = new HttpRequestMessage(method, url))
{
SetAutorizationHeader(requestMessage, customToken, username, password);
await SetContent(data, requestMessage, encodedContent);
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
return(response);
}
}
public async Task ProxyTheRequest(HttpContext context, HttpRequestMessage proxyRequest, IWMSRule proxyRule)
{
try
{
using (var responseMessage = await _httpClientWrapper.SendAsync(proxyRequest, context.RequestAborted))
{
if (proxyRule.PreProcessResponse)
{
await _wmsMessageProcessor.PreProcess(context, responseMessage);
}
await proxyRule.ResponseModifier(responseMessage, context);
}
}
catch (Exception ex) {
}
}
private async Task <HttpResponseMessage> SendRequestAsync(HttpMethod method, string url, object data = null, Dictionary <string, string> headers = null)
{
using (var requestMessage = new HttpRequestMessage(method, url))
{
await SetContent(data, requestMessage);
if (headers != null)
{
foreach (var i in headers)
{
requestMessage.Headers.Add(i.Key, i.Value);
}
}
return(await client.SendAsync(requestMessage).ConfigureAwait(false));
}
}
/// <summary>
/// Proxy the incoming request to the remote host. This method will mutate the HttpContext response property by
/// copying the content body, headers, and status code from the proxied HTTP request.
/// </summary>
/// <param name="httpContext">The HttpContext of the incoming request.</param>
/// <param name="template">The template (relative route).</param>
/// <returns>An asynchronous Task instance.</returns>
public async Task Proxy(HttpContext httpContext, string template)
{
var targetUri = new Uri($"{_baseUrl}{template}");
var targetRequestMessage = CreateTargetMessage(httpContext, targetUri);
var proxiedResponse = await _httpClient.SendAsync(
targetRequestMessage
, HttpCompletionOption.ResponseHeadersRead
, httpContext.RequestAborted
);
httpContext.Response.StatusCode = (int)proxiedResponse.StatusCode;
CopyFromTargetResponseHeaders(httpContext, proxiedResponse);
await proxiedResponse
.Content
.CopyToAsync(httpContext.Response.Body);
}
public async Task <QuotationResponseDTO> GetQuotation(string currency)
{
var client = _clientFactory.CreateClient("cambio.today");
var url =
$"quotes/{CurrencyMapper.Map(currency)}/ARS/json?quantity=1&key={_cambioTodaySettings.Key}";
var request = new HttpRequestMessage(HttpMethod.Get, url);
var response = await _clientWrapper.SendAsync(client, request);
if (!response.IsSuccessStatusCode)
{
throw new CambioTodayAPIException(CAMBIOTODAYAPI_ERROR_MESSAGE);
}
var contentResponse = await response.Content.ReadAsStringAsync();
var cambioTodayResponse = JsonConvert.DeserializeObject <QuotesModelCTResponse>(contentResponse);
var quotationResponse = _mapper.Map <QuotationResponseDTO>(cambioTodayResponse.Result);
return(quotationResponse);
}
public async Task <string> Get()
{
const string url = "https://www.google.com";
// normally this would be defined more centrally but including here for a quick example
var retryPolicy = Policy
.Handle <HttpRequestException>()
.WaitAndRetryAsync(2, retryCount => TimeSpan.FromSeconds(2),
(exception, timeSpan, retryCount, context) =>
{
_logger.LogWarning(
$"Call to {url} failed - Retry {retryCount} : TimeSpan {timeSpan} : Ex {exception.Message}");
});
var response = await retryPolicy.ExecuteAsync(() =>
{
var request = new HttpRequestMessage(HttpMethod.Get, url);
return(_httpClientWrapper.SendAsync(request));
});
return(response.IsSuccessStatusCode ? "ok" : "not ok");
}
public async Task <int[]> Search(SearchRequest searchRequest)
{
var array = searchRequest.Keywords.Split(',');
var searchKeywords = array.Select(k => k.Trim());
var results = new List <int>();
foreach (var keyword in searchKeywords)
{
if (keyword == string.Empty)
{
results.Add(0);
}
else
{
var requestUrl = $"{_searchOptions.SearchUrl}/search?q={HttpUtility.UrlEncode(keyword)}&num={_searchOptions.ResultSize}";
var request = new HttpRequestMessage(HttpMethod.Get, requestUrl);
var searchResult = await _httpClientWrapper.SendAsync(request);
results.Add(_matchService.Count(searchResult, searchRequest.Url));
}
}
return(results.ToArray());
}
public async Task <List <ServiceMetricsResponse> > GetResposesAsync(List <HttpRequestMessage> httpRequestMessages)
{
var responseTasks = new List <Task <HttpResponseMessage> >();
foreach (var httpRequestMessage in httpRequestMessages)
{
responseTasks.Add(httpClientWrapper.SendAsync(httpRequestMessage));
}
var serviceMetricsResponses = new List <ServiceMetricsResponse>();
foreach (var responseTask in responseTasks)
{
HttpResponseMessage response;
try
{
response = responseTask.Result;
}
catch (AggregateException)
{
continue;
}
if (!response.IsSuccessStatusCode)
{
continue;
}
var serviceMetricsResponse = await response.Content.ReadAsStringAsync();
var serviceMetricsModel = JsonConvert.DeserializeObject <ServiceMetricsResponse>(serviceMetricsResponse);
serviceMetricsResponses.Add(serviceMetricsModel);
}
return(serviceMetricsResponses);
}
private async Task <HttpResponseMessage> GetSubscriptionsAsync(HttpRequestMessage requestMessage)
{
var sendRequest = new HttpRequestMessage(HttpMethod.Get, string.Format(Utils.AllSubscriptionsTemplate, HyakUtils.CSMUrl, Utils.CSMApiVersion));
return(await _clientWrapper.SendAsync(requestMessage, sendRequest));
}