private async Task <ConsulResponse <T> > Call <T>(string commandPath, CancellationToken cancellationToken, bool longPolling)
{
if (_disposed)
{
return new ConsulResponse <T> {
Error = new EnvironmentException("ConsulClient already disposed")
}
}
;
var httpTaskTimeout = GetConfig().HttpTaskTimeout;
var urlTimeout = GetConfig().HttpTimeout;
if (longPolling)
{
commandPath += $"&wait={urlTimeout.TotalSeconds}s";
}
string responseContent;
var consulResult = new ConsulResponse <T> {
ConsulAddress = ConsulAddress.ToString(), CommandPath = commandPath
};
try
{
using (var timeoutcancellationToken = new CancellationTokenSource(httpTaskTimeout))
using (var cancellationSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutcancellationToken.Token))
{
var response = await _httpClient.GetAsync(commandPath, HttpCompletionOption.ResponseContentRead, cancellationSource.Token).ConfigureAwait(false);
using (response)
{
responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
consulResult.StatusCode = response.StatusCode;
consulResult.ResponseContent = responseContent;
consulResult.ResponseDateTime = DateTime.UtcNow;
consulResult.ModifyIndex = TryGetConsulIndex(response);
}
}
}
catch (Exception ex)
{
consulResult.Error = consulResult.ConsulUnreachable(ex);
return(consulResult);
}
Log.Debug(x => x("Response received from Consul",
unencryptedTags: new
{
consulAddress = ConsulAddress,
commandPath,
responseCode = consulResult.StatusCode,
responseContent
}));
return(consulResult);
}
private async Task <ConsulResponse <T> > Call <T>(string commandPath, CancellationToken cancellationToken)
{
if (_disposed)
{
throw new ObjectDisposedException(nameof(ConsulClient));
}
var timeout = GetConfig().HttpTaskTimeout;
string responseContent = null;
var consulResult = new ConsulResponse <T> {
ConsulAddress = ConsulAddress.ToString(), CommandPath = commandPath
};
try
{
using (var timeoutcancellationToken = new CancellationTokenSource(timeout))
using (var cancellationSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutcancellationToken.Token))
{
HttpResponseMessage response = await _httpClient.GetAsync(commandPath, HttpCompletionOption.ResponseContentRead, cancellationSource.Token).ConfigureAwait(false);
using (response)
{
responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
consulResult.StatusCode = response.StatusCode;
consulResult.ResponseContent = responseContent;
consulResult.ResponseDateTime = DateTime.UtcNow;
consulResult.ModifyIndex = TryGetConsulIndex(response);
}
}
}
catch (Exception ex)
{
consulResult.Error = consulResult.ConsulUnreachable(ex);
return(consulResult);
}
Log.Debug(x => x("Response received from Consul",
unencryptedTags: new
{
consulAddress = ConsulAddress,
commandPath,
responseCode = consulResult.StatusCode,
responseContent
}));
return(consulResult);
}
public async Task <EndPointsResult> GetEndPoints(string serviceName)
{
var consulQuery = $"/v1/query/{serviceName}/execute?dc={DataCenter}";
var requestLog = _httpClient.BaseAddress + consulQuery;
string responseContent = null;
HttpStatusCode?statusCode = null;
try
{
using (var response = await _httpClient.GetAsync(consulQuery).ConfigureAwait(false))
{
responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
statusCode = response.StatusCode;
if (statusCode == HttpStatusCode.OK)
{
QueryIsOk(consulQuery, serviceName, queryExists: true);
}
else
{
var exception = new EnvironmentException("Consul response not OK",
unencrypted: new Tags
{
{ "ConsulAddress", ConsulAddress.ToString() },
{ "ServiceDeployment", serviceName },
{ "ConsulQuery", consulQuery },
{ "ResponseCode", statusCode.ToString() },
{ "Content", responseContent }
});
if (responseContent.EndsWith("Query not found", StringComparison.InvariantCultureIgnoreCase))
{
QueryIsOk(consulQuery, serviceName, queryExists: false);
return(ErrorResult(requestLog, ex: null, isQueryDefined: false));
}
Log.Error(_ => _("Error calling Consul", exception: exception));
_failedQueries.TryAdd(consulQuery, exception);
return(ErrorResult(requestLog, exception, true));
}
}
var serializedResponse = (ConsulQueryExecuteResponse)JsonConvert.DeserializeObject(responseContent, typeof(ConsulQueryExecuteResponse), _jsonSettings);
var endpoints = serializedResponse.Nodes.Select(_ => new ConsulEndPoint {
HostName = _.Node.Name, ModifyIndex = _.Node.ModifyIndex, Port = _.Service.Port
}).ToArray();
return(SuccessResult(endpoints, requestLog, responseContent));
}
catch (Exception ex)
{
Log.Error("Error calling Consul", exception: ex, unencryptedTags: new
{
ServiceName = serviceName,
ConsulAddress = ConsulAddress.ToString(),
consulQuery,
ResponseCode = statusCode,
Content = responseContent
});
_failedQueries.TryAdd(consulQuery, ex);
return(ErrorResult(requestLog, ex, true));
}
}
