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); } }