public async Task <TResponse> PostAsync <TRequest, TResponse>(TRequest request,
CancellationToken cancellationToken = default) where TRequest : BaseRequest
where TResponse : class, IBaseResponse
{
var client = _httpClientFactory.Create("http://127.0.0.1:8529");
var httpRequest = new HttpRequest <TRequest, TResponse>(request);
httpRequest.ConstructRequest(() =>
{
var endpoint = string.IsNullOrEmpty(request.CurrentDatabase)
? request.Endpoint
: $"_db/{request.CurrentDatabase}{request.Endpoint}";
var message = new HttpRequestMessage(HttpMethod.Post, endpoint)
{
Content = new StringContent(JsonSerializer.Serialize(request, _jsonSerializerOptions), Encoding.Default, "application/json")
};
if (!string.IsNullOrEmpty(request.AuthenticationToken))
{
message.Headers.Authorization = new AuthenticationHeaderValue("bearer", request.AuthenticationToken);
}
return(message);
});
await httpRequest.SendAsync(client, _jsonSerializerOptions).ConfigureAwait(false);
return(httpRequest.Response);
}
public async Task <TopicSharedAccessPolicy> GetTopicSharedAccessPolicy(string topicName, string policyName)
{
var authToken = await _tokenService.GetAuthToken();
var serviceBusApiHost = _serviceBusApiConfiguration.Endpoint;
using var client = _httpClientFactory.Create();
var relativeUri = $"api/topics/{topicName}/authpolicies/{policyName}";
client.BaseAddress = serviceBusApiHost;
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authToken);
try
{
var response = await client.GetAsync(relativeUri);
var responseJson = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
var url = new Uri(serviceBusApiHost, relativeUri);
var responseCode = response.StatusCode;
throw new ServiceBusApiException($"Unexpected http response {responseCode}: {responseJson} when retrieving topic shared access policy from {url}");
}
var topicSharedAccessPolicy = JsonConvert.DeserializeObject <TopicSharedAccessPolicy>(responseJson);
return(topicSharedAccessPolicy);
}
catch (Exception exception)
{
var url = new Uri(serviceBusApiHost, relativeUri);
throw new ServiceBusApiException($"Could not retrieve topic shared access policy from {url}", exception);
}
}
public GatewayModule(IHttpClientFactory clientFactory, ILogger logger)
{
Get("/productlist", async parameters =>
{
var userId = (int)parameters.userid;
var client = await clientFactory.Create(new Uri("http://*****:*****@basket}", basketProducts);
return(View["productlist", new { ProductList = productList, BasketProducts = basketProducts }]);
});
Delete("/shoppingcart/{userid}", async parameters =>
{
var productId = this.Bind <int>();
var userId = (int)parameters.userid;
HttpClient client = await clientFactory.Create(new Uri("http://*****:*****@basket}", basketProducts);
return(View["productlist", new { ProductList = productList, BasketProducts = basketProducts }]);
});
}
public Res GetFromWebApi <Res>(string serviceUrl, string action, string controller) where Res : new()
{
var httpClient = _httpClientFactory.Create(serviceUrl);
var stringContent = new StringContent(string.Empty);
var response = httpClient.PostAsync($"{httpClient.BaseAddress}/{controller}/{action}",
new StringContent(string.Empty, Encoding.UTF8, "application/json")).Result;
return(HttpClientReponse <Res> .ReadMessage(response));
}
public virtual AutomationSession GetSessionDetail(string sessionId)
{
var result = new SessionDetail();
using (var client = _clientFactory.Create(_configurationProvider.BrowserStackApiUrl))
{
var response = client.GetAsync(GetSessionRelativeUrl(sessionId)).Result;
if (response.IsSuccessStatusCode)
{
result = response.Content.ReadAsAsync <SessionDetail>(client.GetFormatters()).Result;
}
}
return(result.AutomationSession);
}
public async Task <HttpResponseMessage> InvokeService(ConfigurationMapping mapping, CancellationToken?cancellationToken)
{
var endpoint = mapping.CustomEndpoint ?? _configuration.Endpoint;
var apiToken = mapping.CustomApiToken ?? _configuration.ApiToken;
var httpMethod = mapping.CustomHttpMethod ?? _configuration.HttpMethod;
var isPost = WebRequestMethods.Http.Post == httpMethod;
var client = _httpClientFactory.Create(endpoint);
if (!string.IsNullOrEmpty(apiToken))
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiToken);
}
if (isPost)
{
var uriBuilder = new UriBuilder(new Uri(client.BaseAddress, mapping.Service));
var postData = mapping.JsonPostData?.ToString() ?? string.Empty;
return(await client.PostAsync(uriBuilder.Uri, new StringContent(postData), cancellationToken ?? CancellationToken.None));
}
else
{
var uriBuilder = new UriBuilder(new Uri(client.BaseAddress, mapping.Service))
{
Query = mapping.QueryString
};
return(await client.GetAsync(uriBuilder.Uri, cancellationToken ?? CancellationToken.None));
}
}
public CoinCapResponse GetCoinCapData(CoinCapRequest coinCapRequest)
{
var serviceUrl = _serviceEndpoints.Services["CryptoCoinService"].Url;
var httpClient = _httpClientFactory.Create(serviceUrl);
//var stringContent = new StringContent(JsonConvert.SerializeObject(coinCapRequest), Encoding.UTF8, "application/json");
//var response = await httpClient.PostAsync(baseAddress, stringContent);
var baseAddress = new Uri(serviceUrl);
UriBuilder serviceUri = new UriBuilder(baseAddress);
serviceUri.Query = "limit=" + coinCapRequest.Limit + "&convert=" + coinCapRequest.Convert;
var response = httpClient.GetAsync(serviceUri.Uri).Result;
if (response.IsSuccessStatusCode)
{
var responseData = response.Content.ReadAsStringAsync().Result;
var dataList = JsonConvert.DeserializeObject <List <CapCoinInfo> >(responseData);
var result = new CoinCapResponse();
result.Coins = dataList.AsEnumerable();
return(result);
}
return(new CoinCapResponse());
}
protected override async Task <int> DoExecuteAsync(ITaskContextInternal context)
{
var client = _httpClientFactory.Create(GitterBaseUrl);
client.DefaultRequestHeaders.Authorization = !string.IsNullOrEmpty(_token)
? new AuthenticationHeaderValue("Bearer", _token)
: null;
var uri = new Uri($"{GitterBaseUrl}/v1/rooms/{_room}/chatMessages");
HttpRequestMessage requestMessage = new HttpRequestMessage();
requestMessage.RequestUri = uri;
requestMessage.Method = HttpMethod.Post;
requestMessage.Content = new FormUrlEncodedContent(new Dictionary <string, string> {
{ "text", _message }
});
var response = await client.SendAsync(requestMessage);
if (!response.IsSuccessStatusCode)
{
throw new TaskExecutionException(await response.Content.ReadAsStringAsync(), 20);
}
return(0);
}
private async Task <HttpResponseMessage> GetHttpResponseAsync(HttpRequestMessage request)
{
try
{
Requires.NonNull(request.RequestUri, nameof(request.RequestUri));
Requires.NonNull(request.Method, nameof(request.Method));
var httpClient = HttpClientFactory.Create();
var response = httpClient.SendAsync(request);
return(await response);
}
catch (Exception e)
{
throw;
}
}
public async Task <IActionResult> GetFromHttpClient()
{
HttpClient client = _httpClientFactory.Create();
var response = await client.GetStringAsync("http://localhost:441/service/get");
return(await JsonAsync(response));
}
public async Task FlushAsync(CancellationToken cancellationToken = default(CancellationToken))
{
// Do nothing if no events were created
if (this.eventGridEvents == null || this.eventGridEvents.Count == 0)
{
return;
}
var sasKey = Utils.MergeValueForProperty(attr.SasKey, config.SasKey);
if (string.IsNullOrEmpty(sasKey))
{
throw new ArgumentException("Sas Key is missing", nameof(sasKey));
}
var topicEndpoint = Utils.MergeValueForProperty(attr.TopicEndpoint, config.TopicEndpoint);
if (string.IsNullOrEmpty(topicEndpoint))
{
throw new ArgumentException("Topic endpoint is missing", nameof(topicEndpoint));
}
string jsonContent = JsonConvert.SerializeObject(this.eventGridEvents);
var content = new StringContent(jsonContent, Encoding.UTF8, "application/json");
content.Headers.Add("aeg-sas-key", sasKey);
var response = await httpClientFactory.Create().PostAsync(topicEndpoint, content);
if (!response.IsSuccessStatusCode)
{
throw new Exception($"Error sending event grid events (code: {response.StatusCode})");
}
}
/// <inheritdoc />
public async Task <IEnumerable <Video> > Search(string id)
{
var uri = $"{options.Address}movie/{id}/videos?api_key={options.ApiKey}";
// Try getting the result from the cache
var videos = await cache.GetAsJsonAsync <IEnumerable <Video> >(uri).ToList();
if (videos == null)
{
// Fetch the results
var client = factory.Create();
var response = await Policies.Retry.ExecuteAsync(() => client.GetAsJson(uri));
// Parse the results
videos = new List <Video>();
foreach (var result in response.results)
{
if (result.type != "Trailer")
{
continue;
}
Video video = ParseVideo(result);
videos.Add(video);
}
// Store the values in the cache
await cache.SetAsJsonAsync(uri, videos, cacheOptions);
}
return(videos);
}
public HttpCreateItemHandler(
IHttpClientFactory httpClientFactory,
ILogger <HttpCreateItemHandler <TModel, TOutputDto> > logger)
{
this.httpClient = httpClientFactory?.Create() ?? throw new ArgumentNullException(nameof(httpClientFactory));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public IJsonHttpClient Create(HttpAuthentication auth)
{
return(new JsonHttpClient(
_httpClientFactory.Create(auth),
_serializers,
_jmesPathQuery,
_secretTracker));
}
public HttpLazyDataSetItemManipulator(
IHttpClientFactory httpClientFactory,
ITypePropertyAccessorCache propertyValueAccessorCache,
ILogger <HttpLazyDataSetItemManipulator <TItem> > logger)
{
_httpClient = httpClientFactory?.Create() ?? throw new ArgumentNullException(nameof(httpClientFactory));
_propertyValueAccessorCache = propertyValueAccessorCache ?? throw new ArgumentNullException(nameof(propertyValueAccessorCache));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public IHttpClient Build()
{
var handler = new HttpClientHandler();
var certificates = clientCertificateProvider.GetCertificates().ToArray();
handler.ClientCertificates.AddRange(certificates);
return(httpClientFactory.Create(handler));
}
public async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, TimeSpan timeout)
{
using (var client = _httpClientFactory.Create()) {
if (timeout <= TimeSpan.Zero)
{
return(await client.SendAsync(request).ConfigureAwait(false));
}
var cancellationToken = new CancellationTokenSource(timeout).Token;
return(await client.SendAsync(request, cancellationToken).ConfigureAwait(false));
}
}
public async Task <IEnumerable <string> > Get()
{
using (var client = _httpClientFactory.Create("http://localhost:56370/"))
{
var response = await client.GetAsync("api/Home/");
var result = await response.Content.ReadAsAsync <string[]>();
return(result.AsEnumerable());
}
}
protected HttpClient GetClient()
{
var client = _clientFactory.Create();
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.cmykhub+json"));
client.DefaultRequestHeaders.Add("ResellerId", _resellerId);
client.DefaultRequestHeaders.Add("APIKey", _apiKey);
return(client);
}
protected async Task <TResult> GetData <TResult>(string endpoint,
bool addAuthorizationToken = true, bool doRetry = true)
{
using (var client = _httpClientFactory.Create(_baseAddress))
{
if (addAuthorizationToken)
{
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + SessionToken);
}
var httpResponse = await client.GetAsync(endpoint);
if (!httpResponse.IsSuccessStatusCode)
{
switch (httpResponse.StatusCode)
{
case HttpStatusCode.Unauthorized:
if (!doRetry)
{
throw new UnauthorizedAccessException();
}
await GetNewAccessToken();
return(await GetData <TResult>(endpoint,
addAuthorizationToken,
false));
case HttpStatusCode.NotFound:
throw new FileNotFoundException();
default:
var exception = new Exception($"Resource server returned an error. StatusCode : {httpResponse.StatusCode}");
exception.Data.Add("StatusCode", httpResponse.StatusCode);
throw exception;
}
}
return(await httpResponse.Content.ReadAsAsync <TResult>());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FileUploader"/> class.
/// </summary>
/// <param name="logger">
/// The logger.
/// </param>
/// <param name="hosts">
/// The hosts.
/// </param>
/// <param name="httpClientFactory">
/// The http client factory.
/// </param>
/// <param name="username">
/// The username.
/// </param>
/// <param name="password">
/// The password.
/// </param>
public FileUploader(ILogger logger, List <string> hosts, IHttpClientFactory httpClientFactory, string username, string password)
{
this.logger = logger;
this.hosts = hosts;
this.username = username;
this.password = password;
this.httpClient = httpClientFactory.Create();
this.httpClient.DefaultRequestHeaders.Accept.Clear();
this.AddAuthorizationToken(this.httpClient);
}
public void GetSessionDetail_ShouldGetBrowserStackSessionDetailWhenStatusIsOk()
{
// Arrange
var sessionId = Guid.NewGuid().ToString();
const string baseAddress = "http://some/address";
var client = Substitute.For <IHttpClient>();
_clientFactory.Create(baseAddress).Returns(client);
var session = new SessionDetail {
AutomationSession = new AutomationSession {
Name = "blah"
}
};
var content = new ObjectContent <SessionDetail>(session, new JsonMediaTypeFormatter());
_configurationProvider.BrowserStackApiUrl.Returns(baseAddress);
client
.GetAsync($"sessions/{sessionId}.json")
.Returns(Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = content
}));
// Act
var result = _sut.GetSessionDetail(sessionId);
// Assert
result.Should().BeSameAs(session.AutomationSession);
client.Received().GetFormatters();
}
/// <inheritdoc />
public async Task <Movie> Get(string id)
{
var uri = $"{options.Address}movie/{id}?api_key={options.ApiKey}";
// Try getting the result from the cache
var movie = await cache.GetAsJsonAsync <Movie>(uri);
if (movie == null)
{
// Fetch the movie from the API
var client = factory.Create();
var response = await Policies.Retry.ExecuteAsync(() => client.GetAsJson(uri));
// Parse the movie
movie = ParseMovie(response);
// Store the value in the cache
await cache.SetAsJsonAsync(uri, movie, cacheOptions);
}
return(movie);
}
public Hello(IHttpClientFactory clientFactory)
{
Get("/", async(_, __) =>
{
var client = await
clientFactory.Create(
new Uri("http://otherservice/"),
"scope_for_other_microservice");
var resp = await
client.GetAsync("/some/path").ConfigureAwait(false);
return(resp.StatusCode);
});
}
static void BasicUsage()
{
IServiceContainer container = new ServiceContainer();
//pool size 32
//configuration action is executed before each factory.Create() usage
container.AddHttpClient(32, httpClient => { httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", "Token..."); });
//IHttpClientFactory is injectable
IHttpClientFactory factory = container.Get <IHttpClientFactory>();
HttpClient client = factory.Create();
//use client here
}
public async Task Invoke(HttpContext context)
{
var httpClient = httpClientFactory.Create(HttpClientType.HttpClient);
var requestMessage = CreateHttpRequestMessage(context);
using (var responseMessage = await httpClient.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead))
{
await UpdateHttpResponseMessage(context, responseMessage);
}
await next(context);
}
public DownstreamClient(IHttpClientFactory httpClientFactory, ICredentialService credentialService, IConfigService configService, TcpClient client)
{
_httpClientFactory = httpClientFactory;
_credentialService = credentialService;
_configService = configService;
_downstreamClient = httpClientFactory.Create(client);
_disallowedHosts = configService.Config.ParsedDisallowedHosts.ToImmutableArray();
_forwardProxyHttp = configService.Config.ForwardProxies?.Http;
_forwardProxyHttps = configService.Config.ForwardProxies?.Https;
_noProxyHosts = (configService.Config.ForwardProxies?.ParsedNoProxyHosts ?? Enumerable.Empty <Host>()).ToImmutableArray();
Id = _nextId++;
}
public async Task <QuoteModel> GetQuote(string symbol)
{
using (var client = _httpClientFactory.Create())
{
var response = await client.GetAsync($"{_quotesConfig.GetApiBaseUrl()}/Quote?symbol={symbol}");
response.EnsureSuccessStatusCode();
var json = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <QuoteModel>(json));
}
}
public OrchestraRxTokenResponse Authenticate()
{
var httpClient = HttpClientFactory.Create();
var plainTextBytes = Encoding.UTF8.GetBytes($"{Config.Key}:{Config.Secret}");
var base64KeySecret = Convert.ToBase64String(plainTextBytes);
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", $"Basic {base64KeySecret}");
var tokenRequestFormContent = new Dictionary <string, string>
{
["grant_type"] = "client_credentials",
};
var content = new FormUrlEncodedContent(tokenRequestFormContent);
var response = httpClient.PostAsync(Config.AuthUrl, content).Result;
var json = response.Content.ReadAsStringAsync().Result;
var tokenResponse = JsonConvert.DeserializeObject <OrchestraRxTokenResponse>(json);
return(tokenResponse);
}
public async Task <string> PostAsync(Uri uri, string content)
{
using (var client = _httpClientFactory.Create())
{
var clientAddress = uri.GetLeftPart(UriPartial.Authority);
client.BaseAddress = new Uri(clientAddress);
var content = new StringContent(content, Encoding.UTF8, "application/json");
var uriAbsolutePath = uri.AbsolutePath;
var response = await client.PostAsync(uriAbsolutePath, content);
var responseJson = response.Content.ReadAsStringAsync().Result;
return(responseJson);
}
}