Communicate.HttpClient 1.1.1

Usage

Creating the client

To use the HTTP-client you need to either dependency inject it as a singleton or make the client into a singleton manually. You should in most cases provide one client per base url you want to communicate with. The client is created through the HttpRestClientFactory like this:

private static HttpRestClient<DefaultHttpClientConfiguration> ApiClient { get; set; }

public static HttpRestClient<DefaultHttpClientConfiguration> GetApiClient()
{
        lock (ApiClientLock)
        {
            if (ApiClient == null)
            {
                ApiClient = HttpRestClientFactory.Create(Settings.GetAppSetting("ApiBaseUrl"), 0);
                ApiClient.AddDefaultHeader(HttpRequestHeaders.ContentType, ContentTypes.ApplicationJson);
                ApiClient.AddDefaultHeader(HttpRequestHeaders.Accept, ContentTypes.ApplicationJson);

                ApiClient.SetOauth2BearerAuthentication(Settings.GetAppSetting("OAuthUrl"),
                    Settings.GetAppSetting("OAuth_client_id"),
                    Settings.GetAppSetting("OAuth_client_secret"),
                    Settings.GetAppSetting("OAuth_grant_type"),
                    null,
                    Settings.GetAppSetting("OAuth_resource"));
            }
        }

        return MessageHubApiClient;
}

This method makes the client into a singleton manually. If you use .net core and/or dependency injection you can just inject the client via services.AddSingleton()

Retrying requests

To retry requests you can either specify the default retry count when creating the client like this HttpRestClientFactory.Create("BaseUrl", 4)` This would make requests retry 4 times based on the following default calculation:

    public virtual bool IsTransient(Exception ex)
    {
        if(ex == null)
        {
            return false;
        }
        else if(ex is HttpRestClientResponseException)
        {
            return TransientStatusCodes.Contains(((HttpRestClientResponseException)ex).StatusCode); //Where TransientCodes are: 504, 408, 503, 0
        }
        else if (ex is TaskCanceledException) //Most likely caused by a timeout, probably transient
        {
            return true;
        }
        else if (ex is HttpRequestException)
        {
            return true;
        }
        else
            return false;
    } 

If you want more control over retrying however you can supply the client with a TransientFaultDetectionStrategy this is an interface that specifies exactly which codes are transient. The following is an example of a custom retry strategy:

ITransientFaultDetectionStrategy faultStrat = HttpRestClientFactory.CreateTransientFaultDetectionStrategy((statusCode) =>
{
	if (statusCode == StatusCodes.Status404NotFound)
		return true;
	else if (statusCode == StatusCodes.Status503ServiceUnavailable)
		return true;
	else if (statusCode == StatusCodes.Status502BadGateway)
		return true;
	else if (statusCode == StatusCodes.Status504GatewayTimeout)
		return true;
	return true;

}, isExceptionTransient: true);

All fault strategies are retried with an exponential interval calculated thus TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))); with a timeout of 30 seconds.

Constants

The above example also uses the packages' internal constants for content type and request headers ApiClient.AddDefaultHeader(HttpRequestHeaders.ContentType, ContentTypes.ApplicationJson), this list of constants makes life easier when specifying return types and header types.

Authorization & Authentication

The client has built in support for Oauth2 and basic auth. The example above adds a OAuth header to every request and automatically manages the life time based on the specified lifetime of the token. This functionality need to be imported specifically through using Communicate.Http.OAuth;.

Serializers

The client returns a string by default or an object if you use the type specification on the method, ie. await ApiClient.Post<MyCustomType>("content"); If the object needs to be serialized from something other than JSON you can specify this when creating the client from the factory like so

            OAuthClient.UseFormUrlDeserializer(); //Specifies the deserialization type when receiving response objects
            OAuthClient.UseFormUrlSerializer(); //Specifies the serialization type on outbound when sending the request

The client currently supports JSON (Default), XML and URL content serializers. As specified below you can provide your own serializer by overriding the configuration.

Using the client

To use the client simply get the client and use the preferred verb like this:

HttpRestClient<DefaultHttpClientConfiguration> httpClient = HttpClientHelper.ApiClient();
mappedMsg = await httpClient.Post<string>("url", request);

If you are in need of a verb the client does not support or need more control over your request a Custom method is available for use like this:

await httpClient.Custom(HttpMethod.Options, "Url", "new message");

This method is not to be confused with the SendAsync() method which looks the same as Custom but skips all the internal functionality built into the client. SendAsync() is used when you need to make a request that skips all the options set in the creation of the client and/or you need total control over the request itself runtime.

Overriding the configuration

If you need total control over the retry options or ingress and egress serializes you can override the IHttpClientConfiguration. The default implementation looks like this:

/// <summary>
/// Default implementation of IHttpClientConfiguration.
/// By default it uses Json as ingress and egress type.
/// It uses a basic retry policy with exponential backoff, and a timeout duration of 30 seconds.
/// </summary>
public abstract class HttpClientConfiguration : IHttpClientConfiguration
{
    private IHttpContentSerializer GetSerializer(ContentType t)
    {
        if (t == ContentType.Xml)
            return new XmlContentSerializer();
        else if (t == ContentType.Urlencoded)
            return new UrlencodedContentSerializer();
        else if (t == ContentType.FormUrlEncoded)
            return new FormUrlEncodedContentSerializer();
        else
            return new JsonContentSerializer();
    }

    public AsyncRetryPolicy RetryStrategy { get; set; }
    public ITransientFaultDetectionStrategy FaultDetection { get; set; } = new DefaultTransientFaultStrategy();
    public TimeSpan TimeoutDuration { get; set; } = TimeSpan.FromSeconds(30);
    public IHttpContentSerializer Deserializer { get; set; }
    public IHttpContentSerializer Serializer { get; set; }
    public Func<Task<AuthenticationHeaderValue>> Authentication { get; set; }
    public bool RefreshAuthBeforeEachRequest { get; set; } = false;
    public HttpMessageHandler HttpClientHandler { get; set; }
    public Uri BaseAddress { get; set; }

    public void UpdateRetryStrategy(int maxRetries)
    {
        RetryStrategy = Policy.Handle<Exception>(x => FaultDetection.IsTransient(x))
                              .WaitAndRetryAsync(maxRetries, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
    }
}