public async Task <TResponse> SendAsync <TResponse>(CancellationToken cancelToken, HttpRequestMessage
request, IDictionary <string, List <string> > headers = null)
{
HttpResponseMessage response = null;
TResponse value = default(TResponse);
if (headers != null)
{
request.AddHeaders(headers);
}
using (HttpCommunicationClient client = new HttpCommunicationClient())
response = await client.HttpClient.SendAsync(request, cancelToken);
if (response.Content != null && response.IsSuccessStatusCode)
{
value = await response.Content.ReadAsAsync <TResponse>(new List <MediaTypeFormatter> {
new JsonMediaTypeFormatter()
}, cancelToken);
}
int statusCode = (int)response.StatusCode;
if ((statusCode >= 500 && statusCode < 600) || statusCode == (int)HttpStatusCode.NotFound)
{
throw new HttpResponseException("Service call failed", response);
}
return(value);
}
public override async Task <Message> HandleMessage(Message msg)
{
MessageContext context = new MessageContext(msg, this);
string dsUrl = await URL.SelectStringAsync(context);
string dsAgent = await UserAgent.SelectStringAsync(context);
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Get, dsUrl);
req.Headers.UserAgent.ParseAdd(dsAgent);
if (Headers != null)
{
req.AddHeaders(context, Headers);
}
try
{
using (HttpClient client = new HttpClient())
{
var result = await client.SendAsync(req);
return(new WebMessage(result.Content.ReadAsStreamAsync())
{
DerivedFrom = msg,
Headers = result.Headers
});
}
}
catch (Exception ex)
{
logger.Error(ex, "{0} thrown when getting {1}: {2}", ex.GetType().Name, req.RequestUri.AbsoluteUri, ex.Message);
return(null);
}
}
public override async Task <Message> HandleMessage(Message msg)
{
MessageContext context = new MessageContext(msg, this);
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Delete, Smart.Format(URL, context));
if (Headers != null)
{
req.AddHeaders(context, Headers);
}
try
{
using (HttpClient client = new HttpClient())
{
var result = await client.SendAsync(req);
return(msg);
}
}
catch (Exception ex)
{
logger.Error(ex, "{0} thrown when deleting {1}: {2}", ex.GetType().Name, req.RequestUri.AbsoluteUri, ex.Message);
return(null);
}
}
private static HttpRequestMessage CreateRequest(HttpRequestBuilderWithoutBodySupport requestBuilder)
{
var request = new HttpRequestMessage(requestBuilder.Method, requestBuilder.Address);
request.AddHeaders(requestBuilder.Headers);
return(request);
}
private static HttpRequestMessage CreateRequest(HttpRequestBuilderWithBody requestBuilder)
{
var request = new HttpRequestMessage(requestBuilder.Method, requestBuilder.Address);
request.Content = requestBuilder.Content;
request.AddHeaders(requestBuilder.Headers);
return(request);
}
private async Task <ApiResponse <T> > SendAsync <T>(
string path,
HttpMethod httpMethod,
IList <KeyValuePair <string, string> > queryParams = null,
IDictionary <string, string> headerParams = null,
IList <KeyValuePair <string, string> > formData = null,
object bodyParams = null) where T : class, new()
{
Ensure.ArgumentNotNullOrEmptyString(path, nameof(path));
path.AddQueryParameters(queryParams);
using (HttpRequestMessage requestMessage = new HttpRequestMessage
{
Method = httpMethod,
RequestUri = new Uri(path, UriKind.RelativeOrAbsolute)
})
{
requestMessage.AddHeaders(headerParams);
requestMessage.AddBody(bodyParams, _jsonSerializerSettings);
requestMessage.AddFormUrlEncodedContent(formData);
using (HttpResponseMessage httpResponseMessage = await _client.SendAsync(requestMessage).ConfigureAwait(false))
{
string content = await httpResponseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
var apiResponse = new ApiResponse <T>
{
HttpStatusCode = httpResponseMessage.StatusCode,
Headers = httpResponseMessage.Content.Headers.ToDictionary(pair => pair.Key, pair => pair.Value.First()),
UrlPath = path
};
if (apiResponse.HttpStatusCode != HttpStatusCode.BadRequest &&
apiResponse.HttpStatusCode != HttpStatusCode.Unauthorized &&
!string.IsNullOrEmpty(content) &&
apiResponse.Headers["Content-Type"].Contains("application/json"))
{
apiResponse.Model = JsonConvert.DeserializeObject <T>(content);
}
else
{
apiResponse.Error = true;
apiResponse.Content = content;
}
return(apiResponse);
}
}
}
async Task <InternalResponse> ExecuteInternal(RestRequest request, CancellationToken cancellationToken)
{
Ensure.NotNull(request, nameof(request));
using var requestContent = new RequestContent(this, request);
if (Authenticator != null)
{
await Authenticator.Authenticate(this, request).ConfigureAwait(false);
}
var httpMethod = AsHttpMethod(request.Method);
var url = BuildUri(request);
var message = new HttpRequestMessage(httpMethod, url)
{
Content = requestContent.BuildContent()
};
message.Headers.Host = Options.BaseHost;
message.Headers.CacheControl = Options.CachePolicy;
using var timeoutCts = new CancellationTokenSource(request.Timeout > 0 ? request.Timeout : int.MaxValue);
using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, cancellationToken);
var ct = cts.Token;
try {
var headers = new RequestHeaders()
.AddHeaders(request.Parameters)
.AddHeaders(DefaultParameters)
.AddAcceptHeader(AcceptedContentTypes);
message.AddHeaders(headers);
if (request.OnBeforeRequest != null)
{
await request.OnBeforeRequest(message).ConfigureAwait(false);
}
var responseMessage = await HttpClient.SendAsync(message, request.CompletionOption, ct).ConfigureAwait(false);
if (request.OnAfterRequest != null)
{
await request.OnAfterRequest(responseMessage).ConfigureAwait(false);
}
return(new InternalResponse(responseMessage, url, null, timeoutCts.Token));
}
catch (Exception ex) {
return(new InternalResponse(null, url, ex, timeoutCts.Token));
}
}
public async Task SucceedGivenHeaderWithWhitespaceCharacters(
IamAuthenticationType iamAuthenticationType,
string method)
{
// Arrange
using var httpClient = HttpClientFactory(iamAuthenticationType).CreateClient("integration");
var request = new HttpRequestMessage(new HttpMethod(method), Context.ApiGatewayUrl);
request.AddHeaders("My-Header1", new[] { "value1", "a b c" });
// Act
var response = await httpClient.SendAsync(request);
// Assert
response.StatusCode.ShouldBe(HttpStatusCode.OK);
}
/// <summary>
/// Send Http Get to the request uri and get HttpResponseMessage
/// </summary>
public static async Task <HttpResponseMessage> GetAsync(Uri requestUri, IDictionary <string, string> headers)
{
// Create new request function
Func <HttpRequestMessage> createRequestMessage = () =>
{
// Create new request
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, requestUri);
// Add headers to request
request.AddHeaders(headers);
return(request);
};
// Send request and get response
HttpResponseMessage response = await ExecuteActionkWithAutoRetry(() => Client.SendAsync(createRequestMessage()));
return(response);
}
public async Task SetAccessToken()
{
using (var cert = Helper.GetX509Certificate2(CertTlsName, CertsPath, CertsPass))
{
var clientHandler = new HttpClientHandler();
clientHandler.ClientCertificates.Add(cert);
clientHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
clientHandler.SslProtocols = SslProtocols.Tls12;
var dataToSend = new Dictionary <string, string>
{
{ "grant_type", "client_credentials" }
};
using (var content = new FormUrlEncodedContent(dataToSend))
using (var client = new HttpClient(clientHandler))
{
bool isSuccess = false;
while (!isSuccess)
{
var request = new HttpRequestMessage(HttpMethod.Post, $"{HttpHost}/oauth2/token");
request.Content = content;
request.AddHeaders(Helper.GetX509Certificate2(CertSignName, CertsPath, CertsPass), await content.DigestValue(), "/oauth2/token", KeyId);
System.Console.WriteLine($"===========REQUEST========\n{request}");
using (HttpResponseMessage response = await client.SendAsync(request))
{
isSuccess = response.IsSuccessStatusCode;
if (isSuccess)
{
System.Console.WriteLine($"===========RESPONSE========\n{response}");
var responseContent = await response.Content.ReadAsStringAsync();
var indexOfEndAccessToken = responseContent.IndexOf(",", 16);
AccessToken = responseContent.Substring(17, indexOfEndAccessToken - 18);
}
else
{
Thread.Sleep(100);
}
}
}
}
}
}
private async Task <string> DoRequest(string url, HttpMethod method, IDictionary <string, string> urlParams = null, object bodyObject = null, IDictionary <string, string> headers = null)
{
string fullRequestUrl = string.Empty;
HttpResponseMessage response = null;
if (headers == null)
{
headers = new Dictionary <string, string>();
}
if (this.Credentials != null)
{
headers.Add("Authorization", this.AuthHeader);
}
headers.Add("Accept", "application/json");
fullRequestUrl = string.Format("{0}{1}{2}", this.Host.ToString(), url, urlParams?.ToQueryString());
using (var request = new HttpRequestMessage(method, fullRequestUrl))
{
request.AddHeaders(headers);
if (bodyObject != null)
{
request.Content = new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(bodyObject), System.Text.Encoding.UTF8, "application/json");
}
response = await this.Client.SendAsync(request).ConfigureAwait(false);
}
var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
var errDesc = response.ReasonPhrase;
if (!string.IsNullOrEmpty(content))
{
errDesc += " - " + content;
}
throw new HttpRequestException(string.Format("RestfulService: Error sending request to web service URL {0}. Reason: {1}", fullRequestUrl, errDesc));
}
return(content);
}
public async Task SucceedGivenHeaderWithWhitespaceCharacters(
IamAuthenticationType iamAuthenticationType,
string method)
{
// Arrange
var request = new HttpRequestMessage(new HttpMethod(method), Context.ApiGatewayUrl);
request.AddHeaders("My-Header1", new[] { "value1", "a b c" });
// Act
var response = await HttpClient.SendAsync(
request,
Context.RegionName,
Context.ServiceName,
ResolveCredentials(iamAuthenticationType));
// Assert
response.StatusCode.ShouldBe(HttpStatusCode.OK);
}
public void SucceedGivenHeaderWithUnorderedValues(
IamAuthenticationType iamAuthenticationType,
string method)
{
// Arrange
var request = new HttpRequestMessage(new HttpMethod(method), Context.ApiGatewayUrl);
request.AddHeaders("My-Header1", new[] { "value4", "value1", "value3", "value2" });
// Act
var response = HttpClient.Send(
request,
Context.RegionName,
Context.ServiceName,
ResolveMutableCredentials(iamAuthenticationType));
// Assert
response.StatusCode.ShouldBe(HttpStatusCode.OK);
}
public override async Task <Message> HandleMessage(Message msg)
{
MessageContext context = new MessageContext(msg, this);
string dsUrl = await URL.SelectStringAsync(context);
HttpRequestMessage req = new HttpRequestMessage(Method, dsUrl);
if (Headers != null)
{
req.AddHeaders(context, Headers);
}
if (msg is IStreamMessage)
{
req.Content = new StreamContent(await((IStreamMessage)msg).GetStream());
}
else
{
string payload = await Payload.SelectStringAsync(context);
req.Content = new StringContent(payload);
}
try
{
using (HttpClient client = new HttpClient())
{
var result = await client.SendAsync(req);
return(new WebMessage(result.Content.ReadAsStreamAsync())
{
DerivedFrom = msg,
Headers = result.Headers
});
}
}
catch (Exception ex)
{
logger.Error(ex, "{0} thrown when sending to {1}: {2}", ex.GetType().Name, req.RequestUri.AbsoluteUri, ex.Message);
return(null);
}
}
/// <summary>
/// Send Http Post to request uri and get HttpResponseMessage
/// </summary>
public static async Task <HttpResponseMessage> PostAsJsonAsync(Uri requestUri, IDictionary <string, string> headers, object content)
{
// Create new request function
Func <HttpRequestMessage> createRequestMessage = () =>
{
// Create new request
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, requestUri);
// Add headers to request
request.AddHeaders(headers);
// Add content as Json
request.AddContentAsJson(content);
return(request);
};
// Post request
HttpResponseMessage response = await ExecuteActionkWithAutoRetry(() => Client.SendAsync(createRequestMessage()));
return(response);
}
/// <summary>
/// Send Http Post to request uri and get HttpResponseMessage
/// </summary>
public static async Task <HttpResponseMessage> PostAsJsonAsync(string requestUri, IDictionary <string, string> headers, object content, bool camelCasePropertyNames, CancellationToken cancellationToken)
{
// Create new request function
HttpRequestMessage createRequestMessage()
{
// Create new request
var request = new HttpRequestMessage(HttpMethod.Post, requestUri);
// Add headers to request
request.AddHeaders(headers);
// Add content as Json
request.AddContentAsJson(content, camelCasePropertyNames);
return(request);
}
// Post request
var response = await ExecuteActionkWithAutoRetry(() => Client.SendAsync(createRequestMessage(), cancellationToken));
return(response);
}
