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; }