protected async Task <T> Request <T>(HttpMethod httpMethod, string requestUri)
{
using (HttpRequestMessage request = new HttpRequestMessage(httpMethod,
requestUri))
{
var accessToken = _tokenProvider.GetToken();
request.Headers.Authorization = new AuthenticationHeaderValue("bearer", accessToken);
using (HttpResponseMessage response =
await _httpClientFactory.GetClient().SendAsync(request).ConfigureAwait(false))
{
if (!response.IsSuccessStatusCode)
{
_logger.LogWarning($"An error occurred while fetching, req: {requestUri}");
}
using (HttpContent httpContent = response.Content)
{
string content = await httpContent.ReadAsStringAsync().ConfigureAwait(false);
return(JsonConvert.DeserializeObject <T>(content));
}
}
}
}
public async Task <IList <UsageDetailItem> > GetUsageDetailsAsync(DownloadUsageDetailsRequest request)
{
var httpClient = _httpClientFactory.GetClient();
SetCredentials(httpClient, request);
SetEtagHeader(httpClient, request);
return(await DownloadUsageDataAsync(httpClient, request).ConfigureAwait(false));
}
public GetStaleImagesCommand(
IDockerService dockerService,
IHttpClientFactory httpClientFactory,
ILoggerService loggerService,
IGitHubClientFactory gitHubClientFactory)
{
this.dockerService = dockerService;
this.loggerService = loggerService;
this.gitHubClientFactory = gitHubClientFactory;
this.httpClient = httpClientFactory.GetClient();
}
public PublishImageInfoCommand(IGitHubClientFactory gitHubClientFactory, ILoggerService loggerService, IHttpClientFactory httpClientFactory)
{
if (httpClientFactory is null)
{
throw new ArgumentNullException(nameof(httpClientFactory));
}
this.gitHubClientFactory = gitHubClientFactory ?? throw new ArgumentNullException(nameof(gitHubClientFactory));
this.loggerService = loggerService ?? throw new ArgumentNullException(nameof(loggerService));
this.httpClient = httpClientFactory.GetClient();
}
protected async Task AssertTopicsCanBeRetrievedByHttpClient()
{
var publisherBaseUri = new Uri("http://localhost:52186/");
using (var httpClient = await _httpClientFactory.GetClient(publisherBaseUri, null))
using (var responseMessage = await httpClient.GetAsync("topic"))
{
Assert.True(responseMessage.IsSuccessStatusCode, "HTTP Status " + responseMessage.StatusCode + " " + responseMessage.ReasonPhrase);
var responseContent = await responseMessage.Content.ReadAsStringAsync();
var topicArray = JsonConvert.DeserializeObject <string[]>(responseContent);
Assert.Contains((string)Topic, topicArray);
}
}
public async Task <UserAvatar> GetAvatarAsync(string email, ImageDimensions dimensions)
{
try
{
var user = await _userRepository.GetUserFromEmailAsync(email);
if (user == null)
{
return(UserAvatar.NotAvailable);
}
var requestUri = new Uri(_config.ApiBaseUrl,
$"/_apis/GraphProfile/MemberAvatars/{user.Descriptor}?size=2");
var client = _httpClientFactory.GetClient();
using (var response = await client.GetAsync(requestUri))
{
if (response.IsSuccessStatusCode)
{
var data = await response.Content.ReadAsByteArrayAsync();
var contentType = response.Content.Headers.ContentType.MediaType;
var type = _imageFormatManager.FindFormatByMimeType(contentType);
using (var image = Image.Load(data))
{
var resizedImage = _imageResizer.Resize(image, dimensions.Height, dimensions.Width);
var bytes = resizedImage.ConvertToByteArray(type);
return(new UserAvatar
{
Data = bytes,
ContentType = contentType
});
}
}
}
}
catch (Exception ex)
{
_logger.LogError($"Error getting Azure Dev Ops users list or user avatar: {ex.Message}");
}
throw new NotImplementedException();
}
private async Task <HttpClient> SetupRequest(object query, RawEndpointResult endpointResult)
{
var httpClient = clientFactory.GetClient();
endpointResult.Request = await clientFactory.GetRequestMessage();
endpointResult.Request.Method = new HttpMethod(link.Method);
var uriBuilder = new UriBuilder(link.Href);
if (query != null)
{
uriBuilder.Query = QueryBuilder.BuildQueryString(query);
}
endpointResult.Request.RequestUri = uriBuilder.Uri;
endpointResult.Request.Headers.Add("Accept", "application/json+halcyon");
return(httpClient);
}
public async Task <BundleApiResult> GetBundlesAsync()
{
var requestUri = $"{_apiConfiguration.BaseUrl}/api/v2/bestbuys?Authorization={_apiConfiguration.ApiKey}";
IList <Bundle> resultBundles;
try
{
using (var httpClient = _httpClientFactory.GetClient())
{
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var httpResponseMessage = await httpClient.GetAsync(requestUri);
if (!httpResponseMessage.IsSuccessStatusCode || httpResponseMessage.Content == null)
{
return(new BundleApiResult()
{
ResponseCode = ResponseCode.Error
});
}
var responseContents = await httpResponseMessage.Content.ReadAsStringAsync();
resultBundles = _bundleResponseDeserializer.Deserialise(responseContents).bundleList;
}
}
catch (Exception)
{
// Todo: Log
return(new BundleApiResult()
{
ResponseCode = ResponseCode.Error
});
}
return(new BundleApiResult()
{
ResponseCode = ResponseCode.Success, Bundles = resultBundles
});
}
public HttpClient GetClient()
{
return(next.GetClient());
}
private async Task TransportMessage(Message message, IEndpointCredentials credentials, CancellationToken cancellationToken = default(CancellationToken))
{
HttpClient httpClient = null;
Uri postUri = null;
int? status = null;
var delivered = false;
var sw = Stopwatch.StartNew();
var httpClientTimeout = TimeSpan.Zero;
var requestInitiated = false;
HttpResponseMessage httpResponseMessage = null;
try
{
if (_messageJournal != null)
{
await _messageJournal.Append(message, MessageJournalCategory.Sent, cancellationToken);
}
var endpointBaseUri = message.Headers.Destination.WithTrailingSlash();
if (_bypassTransportLocalDestination && endpointBaseUri == _baseUri)
{
delivered = await HandleLocalDelivery(message, cancellationToken, endpointBaseUri);
return;
}
postUri = BuildPostMessageUri(out var relativeUri, message, endpointBaseUri);
var httpContent = new StringContent(message.Content);
WriteHttpContentHeaders(message, httpContent);
httpClient = await _httpClientFactory.GetClient(endpointBaseUri, credentials, cancellationToken);
httpClientTimeout = httpClient.Timeout;
requestInitiated = true;
httpResponseMessage = await httpClient.PostAsync(relativeUri, httpContent, cancellationToken);
status = (int)httpResponseMessage.StatusCode;
HandleHttpErrorResponse(httpResponseMessage);
delivered = true;
}
catch (TransportException ex)
{
_diagnosticService.Emit(
new HttpEventBuilder(this, HttpEventType.HttpCommunicationError)
{
Message = message,
Method = HttpMethod.Post.ToString(),
Uri = postUri,
Status = status,
Exception = ex
}.Build());
throw;
}
catch (UnauthorizedAccessException)
{
_diagnosticService.Emit(
new HttpEventBuilder(this, DiagnosticEventType.AccessDenied)
{
Message = message,
Method = HttpMethod.Post.ToString(),
Uri = postUri,
Status = status
}.Build());
throw;
}
catch (MessageNotAcknowledgedException)
{
_diagnosticService.Emit(
new HttpEventBuilder(this, DiagnosticEventType.MessageNotAcknowledged)
{
Message = message,
Method = HttpMethod.Post.ToString(),
Uri = postUri,
Status = status
}.Build());
throw;
}
catch (OperationCanceledException)
{
sw.Stop();
var elapsed = sw.Elapsed;
var cancellationRequested = cancellationToken.IsCancellationRequested;
var timeoutKnown = httpClientTimeout > TimeSpan.Zero;
var timeoutExceeded = requestInitiated && timeoutKnown && elapsed > httpClientTimeout;
var probableTimeout = !cancellationRequested || timeoutExceeded;
var detail = $"HTTP transport operation was canceled after {elapsed.TotalSeconds} second(s). " +
$"Cancellation {(cancellationToken.IsCancellationRequested ? "was" : "was not")} requested by the caller. ";
if (timeoutKnown)
{
detail += $"The HTTP client timeout is set to {httpClientTimeout.TotalSeconds} second(s). ";
}
if (probableTimeout)
{
detail += "Cancelation was likely due to a timeout on the HTTP client. " +
"This may be caused by setting Synchronous to 'true' when sending a message.";
}
_diagnosticService.Emit(
new HttpEventBuilder(this, HttpEventType.HttpCommunicationError)
{
Detail = detail,
Message = message,
Method = HttpMethod.Post.ToString(),
Uri = postUri,
Status = status
}.Build());
throw;
}
catch (Exception ex)
{
var errorMessage = $"Error sending message ID {message.Headers.MessageId}";
_diagnosticService.Emit(
new HttpEventBuilder(this, HttpEventType.HttpCommunicationError)
{
Detail = errorMessage,
Message = message,
Method = HttpMethod.Post.ToString(),
Uri = postUri,
Status = status,
Exception = ex
}.Build());
TryHandleCommunicationException(ex, message.Headers.Destination);
throw new TransportException(errorMessage, ex);
}
finally
{
sw.Stop();
var eventType = delivered
? DiagnosticEventType.MessageDelivered
: DiagnosticEventType.MessageDeliveryFailed;
_diagnosticService.Emit(
new HttpEventBuilder(this, eventType)
{
Message = message,
Method = HttpMethod.Post.ToString(),
Uri = postUri,
Status = status
}.Build());
httpResponseMessage?.Dispose();
httpClient?.Dispose();
}
}
public NetworkClient(IHttpClientFactory factory)
{
//_client = new HttpClient();
_client = factory.GetClient();
}
public TripAdvisorService(IHttpClientFactory httpClientFactory)
{
_httpClientFactory = httpClientFactory;
_httpClient = httpClientFactory.GetClient();
}