private static void WriteBodyContent(IHttpClientRequestContext requestContext, IRequestSerializationStrategy serializer, RestRequest request)
{
//Write the body first to avoid messing with the headers
if (requestContext.BodyContext.HasBody)
{
serializer.TrySerialize(requestContext.BodyContext.Body, new RestSharpRequestBodyWriter(request));
}
}
private static void WriteHeaders(IHttpClientRequestContext requestContext, RestRequest request)
{
//We need to add the headers. We expect that they are already constructed with any formatted or inserted values already inserted.
foreach (IRequestHeader header in requestContext.RequestHeaders)
{
request.AddHeader(header.HeaderType, header.HeaderValue);
}
}
protected FailedHttpRequestException(IHttpClientRequestContext request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
Request = request;
}
protected FailedHttpRequestException(string message, Exception innerException, IHttpClientRequestContext request)
: base(message, innerException)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
Request = request;
}
/// <inheritdoc />
public FailedRestSharpRequestException(string message, IHttpClientRequestContext request, IRestResponse response)
: base(message, request)
{
if (response == null)
{
throw new ArgumentNullException(nameof(response));
}
Response = response;
}
/// <inheritdoc />
public FailedHttpClientRequestException(IHttpClientRequestContext request, HttpResponseMessage response)
: base(request)
{
if (response == null)
{
throw new ArgumentNullException(nameof(response));
}
Response = response;
}
private static void WriteHeaders(IHttpClientRequestContext requestContext, HttpRequestMessage request)
{
//We need to add the headers. We expect that they are already constructed with any formatted or inserted values already inserted.
foreach (IRequestHeader header in requestContext.RequestHeaders)
{
if (!request.Headers.TryAddWithoutValidation(header.HeaderType, header.HeaderValue))
{
throw new InvalidOperationException($"Request failed to add HeaderType: {header.HeaderType} with Value: {header.HeaderValue} with Context: {requestContext}.");
}
}
}
/// <inheritdoc />
public async Task <TReturnType> Send <TReturnType>(IHttpClientRequestContext requestContext, IDeserializationStrategyFactory deserializationFactory)
{
if (requestContext == null)
{
throw new ArgumentNullException(nameof(requestContext));
}
IRestResponse response = await SendHttpRequest(requestContext).ConfigureAwait(false);
return(await FindValidDeserializer(deserializationFactory, response)
.DeserializeAsync <TReturnType>(new RestSharpResponseBodyReader(response))
.ConfigureAwait(false));
}
//TODO: Document
private async Task <HttpResponseMessage> SendHttpRequest(IHttpClientRequestContext requestContext)
{
if (requestContext == null)
{
throw new ArgumentNullException(nameof(requestContext));
}
//Build a request message targeted towards the base URL and the action path built by the caller.
using (HttpRequestMessage request = new HttpRequestMessage(requestContext.RequestMethod, BuildFullUrlPath(requestContext)))
{
WriteHeaders(requestContext, request);
return(await SendBaseRequest(requestContext, request).ConfigureAwait(false));
}
}
//TODO: Document
private Task <IRestResponse> SendHttpRequest(IHttpClientRequestContext requestContext)
{
if (requestContext == null)
{
throw new ArgumentNullException(nameof(requestContext));
}
//Build a request message targeted towards the base URL and the action path built by the caller.
RestRequest request = new RestRequest(ConvertToRestSharpMethod(requestContext.RequestMethod));
request.Resource = BuildFullUrlPath(requestContext);
WriteHeaders(requestContext, request);
return(SendBaseRequest(requestContext, request));
}
public async Task <TResult> AsyncWithReturn <TResult>(IInvocation invocation)
{
//TODO: Handle return data deserialization.
IHttpClientRequestContext context = RequestContextFactory.CreateContext(new CastleCoreInvocationCallContextAdapter(invocation),
new CastleCoreInvocationParametersContextAdapter(invocation));
//If it has no body we don't need to provide or produce serializers for it.
if (!context.BodyContext.HasBody)
{
return(await ProxyClient.Send <TResult>(context, DeserializerFactory));
}
//We need to look at the request to determine which serializer strategy should be used.
IRequestSerializationStrategy serializer = SerializerFactory.SerializerFor(context.BodyContext.ContentAttributeType);
//Because we don't need to get any returned information we can just send it
return(await ProxyClient.Send <TResult>(context, serializer, DeserializerFactory).ConfigureAwait(false));
}
/// <inheritdoc />
protected override async Task <HttpResponseMessage> SendBaseRequest(IHttpClientRequestContext requestContext, HttpRequestMessage request)
{
//TODO: C#7 can await in locks
if (Client.BaseAddress == null)
{
string url = await BaseUrlFuture.ConfigureAwait(false);
lock (SyncObj)
{
if (Client.BaseAddress == null)
{
Client.BaseAddress = new Uri(url);
}
}
}
//At this point due to the above await we will have gotten the URI initialized and can send the request.
return(await base.SendBaseRequest(requestContext, request).ConfigureAwait(false));
}
//Made overridable so implementations can change how the requet is sent.
/// <summary>
/// This method sends a request through the <see cref="Client"/> using the provided built
/// <see cref="HttpRequestMessage"/> and the <see cref="IHttpClientRequestContext"/>.
/// </summary>
/// <param name="requestContext"></param>
/// <param name="request"></param>
/// <returns>A future response.</returns>
protected virtual async Task <HttpResponseMessage> SendBaseRequest(IHttpClientRequestContext requestContext, HttpRequestMessage request)
{
if (Client == null)
{
throw new InvalidOperationException($"The {nameof(HttpClient)} property {nameof(Client)} is null.");
}
//Don't use a using here, the caller has to be responsible for diposing it because they own it, not us. They may need to use it.
HttpResponseMessage response = await Client.SendAsync(request).ConfigureAwait(false);
//Throw a debug viable message if the response is not successful.
//We should only throw if the user didn't request this specific error code to be supressed
if (!response.IsSuccessStatusCode && !requestContext.SupressedErrorCodesContext.SupressedErrorCodes[(int)response.StatusCode])
{
throw new FailedHttpClientRequestException($"Request failed with Code: {response.StatusCode} Reason: {response.ReasonPhrase}", requestContext, response);
}
return(response);
}
//Made overridable so implementations can change how the requet is sent.
/// <summary>
/// This method sends a request through the <see cref="Client"/> using the provided built
/// <see cref="HttpRequestMessage"/> and the <see cref="IHttpClientRequestContext"/>.
/// </summary>
/// <param name="requestContext"></param>
/// <param name="request"></param>
/// <returns>A future response.</returns>
protected virtual async Task <IRestResponse> SendBaseRequest(IHttpClientRequestContext requestContext, RestRequest request)
{
if (Client == null)
{
throw new InvalidOperationException($"The {nameof(HttpClient)} property {nameof(Client)} is null.");
}
IRestResponse response = await Client.ExecuteTaskAsync(request)
.ConfigureAwait(false);
//This indicates that the request encountered a network error: https://github.com/restsharp/RestSharp/wiki/Getting-Started
if (response.ResponseStatus != ResponseStatus.Completed)
{
throw new InvalidOperationException($"Request failed with Code: {response.StatusCode} with Context: {requestContext}.");
}
//It's possible it's still a failed request
if (!IsSuccessStatusCode(response.StatusCode) && !requestContext.SupressedErrorCodesContext.SupressedErrorCodes[(int)response.StatusCode])
{
throw new FailedRestSharpRequestException($"Request failed with Code: {response.StatusCode} Reason: {response.ErrorMessage}", response.ErrorException, requestContext, response);
}
return(response);
}
private string BuildFullUrlPath(IHttpClientRequestContext requestContext)
{
//TODO: Cache this
return(requestContext.ActionPath.TrimStart('/'));
}
/// <inheritdoc />
public async Task Send(IHttpClientRequestContext requestContext)
{
//Send a request WITHOUT serialization which means no body.
//Make sure to dipose the response
(await SendHttpRequest(requestContext).ConfigureAwait(false)).Dispose();
}
private string BuildFullUrlPath(IHttpClientRequestContext requestContext)
{
return(requestContext.ActionPath);
}
/// <inheritdoc />
public Task Send(IHttpClientRequestContext requestContext, IRequestSerializationStrategy serializer)
{
//Make sure to dipose the response
return(SendHttpRequest(requestContext, serializer));
}
/// <inheritdoc />
public Task Send(IHttpClientRequestContext requestContext)
{
//Send a request WITHOUT serialization which means no body.
//Make sure to dipose the response
return(SendHttpRequest(requestContext));
}
/// <inheritdoc />
public async Task Send(IHttpClientRequestContext requestContext, IRequestSerializationStrategy serializer)
{
//Make sure to dipose the response
(await SendHttpRequest(requestContext, serializer).ConfigureAwait(false)).Dispose();
}
