private async Task <StatusResultServiceModel> PingServiceAsync(string serviceName, string serviceURL)
{
var result = new StatusResultServiceModel(false, $"{serviceName} check failed");
try
{
var response = await this.httpClient.GetAsync(this.PrepareRequest($"{serviceURL}/status"));
if (!response.IsSuccessStatusCode)
{
result.Message = $"Status code: {response.StatusCode}; Response: {response.Content}";
}
else
{
var data = JsonConvert.DeserializeObject <StatusServiceModel>(response.Content);
result = data.Status;
}
}
catch (Exception e)
{
this.log.Error(result.Message, () => new { e });
}
return(result);
}
public async Task <StatusResultServiceModel> PingConfigServiceAsync()
{
var result = new StatusResultServiceModel(false, "Config check failed");
if (string.IsNullOrEmpty(this.config.PcsConfigUrl))
{
return(result);
}
try
{
var pcsConfigUrl = this.config.PcsConfigUrl + "/status";
var request = new HttpRequest();
request.SetUriFromString(pcsConfigUrl);
IHttpResponse response = await this.httpClient.GetAsync(request);
if (response.IsError)
{
result.Message = $"Status code: {response.StatusCode}; Response: {response.Content}";
}
else
{
var data = JsonConvert.DeserializeObject <StatusServiceModel>(response.Content);
result = data.Status;
}
}
catch (Exception e)
{
this.logger.Error(result.Message, () => new { e });
}
return(result);
}
public async Task <StatusResultServiceModel> PingAsync()
{
var result = new StatusResultServiceModel(false, "Storage check failed");
try
{
IAsyncCursor <BsonDocument> response = null;
if (this.mongoClient != null)
{
// make generic call to see if storage client can be reached
response = await this.mongoClient.ListDatabasesAsync();
}
if (response.ToList().Count > 0)
{
result.IsHealthy = true;
result.Message = "Alive and Well!";
}
}
catch (Exception e)
{
this.log.Info(result.Message, () => new { e });
}
return(result);
}
public async Task GetHealthyStatusAsyncTest()
{
var healthyStatus = new StatusResultServiceModel(true, "all good");
var response = new HttpResponse
{
StatusCode = HttpStatusCode.OK,
IsSuccessStatusCode = true,
Content = JsonConvert.SerializeObject(healthyStatus),
};
this.mockHttpClient
.Setup(
x => x.SendAsync(
It.IsAny <IHttpRequest>(),
It.Is <HttpMethod>(method => method == HttpMethod.Get)))
.ReturnsAsync(response);
var result = await this.client.StatusAsync();
this.mockHttpClient
.Verify(
x => x.SendAsync(
It.Is <IHttpRequest>(r => r.Check($"{MockServiceUri}/status")),
It.Is <HttpMethod>(method => method == HttpMethod.Get)),
Times.Once);
Assert.Equal(result.IsHealthy, healthyStatus.IsHealthy);
Assert.Equal(result.Message, healthyStatus.Message);
}
public async Task <StatusResultServiceModel> PingDiagnosticsEndpointAsync()
{
var result = new StatusResultServiceModel(false, "Diagnostics Azure Function check failed");
var endpointUrl = this.config.DiagnosticsEndpointUrl;
string data = "Ping Diagnostics service";
try
{
var request = new HttpRequest();
request.SetUriFromString(endpointUrl);
StringContent content = new StringContent(data, Encoding.UTF8, "application/json");
request.SetContent(content);
var response = await this.httpClient.PostAsync(request);
if (response.IsError)
{
result.Message = $"Status code: {response.StatusCode}; Response: {response.Content}";
}
else
{
result.IsHealthy = true;
result.Message = "Alive and Well!";
}
}
catch (Exception e)
{
this.logger.Error(result.Message, () => new { e });
}
return(result);
}
public async Task <StatusResultServiceModel> StatusAsync()
{
var result = new StatusResultServiceModel(false, "Storage check failed");
try
{
DatabaseAccount response = null;
if (this.client != null)
{
// make generic call to see if storage client can be reached
response = await this.client.GetDatabaseAccountAsync();
}
if (response != null)
{
result.IsHealthy = true;
result.Message = "Alive and Well!";
}
}
catch (Exception e)
{
this.logger.LogInformation(e, result.Message);
}
return(result);
}
private async Task <StatusResultServiceModel> PingEventHubAsync()
{
var result = new StatusResultServiceModel(false, "EventHub check failed");
var connectionStringBuilder = new EventHubsConnectionStringBuilder(
this.servicesConfig.EventHubConnectionString)
{
EntityPath = this.servicesConfig.EventHubName
};
EventHubClient eventHubClient = EventHubClient.CreateFromConnectionString(
connectionStringBuilder.ToString());
try
{
await eventHubClient.GetRuntimeInformationAsync();
result.Message = "Alive and well!";
result.IsHealthy = true;
}
catch (Exception e)
{
this.log.Error(result.Message, () => new { e });
}
return(result);
}
private void SetServiceStatus(string dependencyName, StatusResultServiceModel serviceResult, StatusServiceModel result, IList <string> errors)
{
if (!serviceResult.IsHealthy)
{
errors.Add(dependencyName + " check failed");
result.Status.IsHealthy = false;
}
result.Dependencies.Add(dependencyName, serviceResult);
}
public async Task GetAppConfigStatusReturnsUnhealthyOnExceptionTest()
{
Response <ConfigurationSetting> response = Response.FromValue(ConfigurationModelFactory.ConfigurationSetting(string.Empty, string.Empty), this.mockResponse.Object);
this.client.Setup(c => c.GetConfigurationSettingAsync(string.Empty, It.IsAny <string>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(response);
StatusResultServiceModel result = await this.appConfigClient.StatusAsync();
Assert.False(result.IsHealthy);
}
public async Task GetAppConfigStatusReturnsHealthyTest()
{
this.mockConfig.Setup(x => x.Global.Location).Returns("eastus");
Response <ConfigurationSetting> response = Response.FromValue(ConfigurationModelFactory.ConfigurationSetting("test", "test"), this.mockResponse.Object);
this.client.Setup(c => c.GetConfigurationSetting(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>()))
.Returns(response);
StatusResultServiceModel result = await this.appConfigClient.StatusAsync();
Assert.True(result.IsHealthy);
}
// Ping the registry to see if the connection is healthy
public async Task <StatusResultServiceModel> PingRegistryAsync()
{
var result = new StatusResultServiceModel(false, "");
try
{
await this.registry.GetDeviceAsync("healthcheck");
result.IsHealthy = true;
result.Message = "Alive and Well!";
}
catch (Exception e)
{
result.Message = e.Message;
}
return(result);
}
// Ping the registry to see if the connection is healthy
public async Task <StatusResultServiceModel> StatusAsync()
{
var result = new StatusResultServiceModel(false, string.Empty);
try
{
await this.tenantConnectionHelper.GetRegistry().GetDeviceAsync("healthcheck");
result.IsHealthy = true;
result.Message = "Alive and Well!";
}
catch (Exception e)
{
result.Message = e.Message;
}
return(result);
}
public async Task <StatusResultServiceModel> StatusAsync()
{
var result = new StatusResultServiceModel(false, "TimeSeries check failed");
if (this.timeSeriesEnabled == true)
{
// Acquire an access token.
string accessToken = string.Empty;
try
{
accessToken = await this.AcquireAccessTokenAsync();
// Prepare request
HttpRequest request = this.PrepareRequest(
AvailabilityKey,
accessToken,
new[] { TimeSeriesTimeoutPrefix + "=" + this.timeout });
var response = await this.httpClient.GetAsync(request);
// Return status
if (!response.IsError)
{
result.IsHealthy = true;
result.Message = "Alive and well!";
}
else
{
result.Message = $"Status code: {response.StatusCode}; Response: {response.Content}";
}
}
catch (Exception e)
{
this.logger.LogError(e, result.Message);
}
}
else
{
result.IsHealthy = true;
result.Message = "Service disabled not in use";
}
return(result);
}
// Check if database exist
public async Task <StatusResultServiceModel> PingAsync()
{
var result = new StatusResultServiceModel(false, "Storage check failed");
try
{
this.ParseConnectionString(out var uri, out var authKey);
await this.cosmosSqlWrapper.ReadDatabaseAsync(uri, authKey, this.database);
// If ReadDatabaseAsync doesn't throw exception, connection is healthy
result.IsHealthy = true;
result.Message = "Alive and well!";
}
catch (Exception e)
{
this.log.Error(result.Message, () => new { e });
}
return(result);
}
public async Task <StatusResultServiceModel> PingAsync()
{
var result = new StatusResultServiceModel(false, "Blob check failed");
try
{
IDatabase cache = lazyConnection.Value.GetDatabase();
var response = await cache.ExecuteAsync("PING");
if (response.ToString() == "PONG")
{
result.Message = "Alive and well!";
result.IsHealthy = true;
}
}
catch (Exception e)
{
this.logger.Error(result.Message, () => new { e });
}
return(result);
}
public async Task <StatusResultServiceModel> PingAsync()
{
var result = new StatusResultServiceModel(false, "Blob helper in device telemetry check failed");
try
{
this.InitializeBlobStorage();
ServiceProperties response = await this.cloudBlobClient.GetServicePropertiesAsync();
if (response != null)
{
result.Message = "Alive and well!";
result.IsHealthy = true;
}
}
catch (Exception e)
{
this.logger.Error(result.Message, () => new { e });
}
return(result);
}
public async Task <StatusResultServiceModel> PingAsync()
{
var result = new StatusResultServiceModel(false, "Blob check failed");
try
{
await this.InitializeBlobStorage();
var response = await this.cloudBlobContainer.ExistsAsync();
if (response)
{
result.Message = "Alive and well!";
result.IsHealthy = true;
}
}
catch (Exception e)
{
this.logger.Error(result.Message, () => new { e });
}
return(result);
}
/// <summary>
/// Makes a request to the environment availability API to verify
/// that the fqdn provided can reach Time Series Insights.
/// Returns a tuple with the status [bool isAvailable, string message].
/// </summary>
public async Task <StatusResultServiceModel> PingAsync()
{
var result = new StatusResultServiceModel(false, "TimeSeries check failed");
// Acquire an access token.
string accessToken = "";
try
{
accessToken = await this.AcquireAccessTokenAsync();
// Prepare request
HttpRequest request = this.PrepareRequest(
AVAILABILITY_KEY,
accessToken,
new[] { TIME_SERIES_TIMEOUT_PREFIX + "=" + this.timeout });
var response = await this.httpClient.GetAsync(request);
// Return status
if (!response.IsError)
{
result.IsHealthy = true;
result.Message = "Alive and well!";
}
else
{
result.Message = $"Status code: {response.StatusCode}; Response: {response.Content}";
}
}
catch (Exception e)
{
this.log.Error(result.Message, () => new { e });
}
return(result);
}
public StatusResultApiModel(StatusResultServiceModel servicemodel)
{
this.IsHealthy = servicemodel.IsHealthy;
this.Message = servicemodel.Message;
}
