private void checkHttpStatus(ref HealthCheckResponse response, string url) { HttpWebRequest myRequest; HttpWebResponse myResponse = null; try { myRequest = (HttpWebRequest)WebRequest.Create(url); myResponse = (HttpWebResponse)myRequest.GetResponse(); if ((int)myResponse.StatusCode >= 200 && (int)myResponse.StatusCode < 300) { _data.Add(url, State.UP); } else { response.Down(); _data.Add(url, State.DOWN); } } catch { response.Down(); _data.Add(url, State.DOWN); } finally { if (myResponse != null) { myResponse.Close(); } } }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } // Enable Middelware to serve generated Swager as JSON endpoint var swaggerOptions = new SwaggerOptions(); Configuration.GetSection(nameof(SwaggerOptions)).Bind(swaggerOptions); app.UseSwagger(option => { option.RouteTemplate = swaggerOptions.JsonRoute; }); // Enable Middelware to serve Swagger UI (HTML, JavaScript, CSS etc.) app.UseSwaggerUI(option => { option.SwaggerEndpoint(swaggerOptions.UIEndpoint, swaggerOptions.Description); }); // Enable Health Check Middleware app.UseHealthChecks("/health", new HealthCheckOptions { ResponseWriter = async(context, report) => { context.Response.ContentType = "application/json"; var response = new HealthCheckResponse() { Status = report.Status.ToString(), Checks = report.Entries.Select(x => new HealthCheck { Status = x.Value.Status.ToString(), Component = x.Key, Description = x.Value.Description }), Duration = report.TotalDuration }; await context.Response.WriteAsync(text: JsonConvert.SerializeObject(response)); } }); app.UseCustomExceptionHandler(); app.UseHttpsRedirection(); app.UseRouting(); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapControllers(); }); }
public static void AddHealthChecksMiddleware(this IApplicationBuilder app) { app.UseHealthChecks("/healthcheck", new HealthCheckOptions { Predicate = _ => false }); app.UseHealthChecks("/healthcheck/dependencies", new HealthCheckOptions { ResponseWriter = async(context, report) => { context.Response.ContentType = "application/json"; var response = new HealthCheckResponse { Status = report.Status.ToString(), Checks = report.Entries.Select(e => new HealthCheck { Status = e.Value.Status.ToString(), Component = e.Key, Description = e.Value.Description }), Duration = report.TotalDuration }; await context.Response.WriteAsync(JsonConvert.SerializeObject(response)); } }); }
public static IApplicationBuilder UseCustomHealthchecks(this IApplicationBuilder app) { app.UseHealthChecks("/health", new HealthCheckOptions { ResponseWriter = async(context, report) => { context.Response.ContentType = "application/json"; var response = new HealthCheckResponse { status = report.Status.ToString(), Checks = report.Entries.Select(x => new HealthCheck { Componenet = x.Key, status = x.Value.Status.ToString(), Description = x.Value.Description }), Duration = report.TotalDuration }; await context.Response.WriteAsync(JsonConvert.SerializeObject(response)); } }) ; app.UseHealthChecksUI(); return(app.UseHealthChecks("/ready", new HealthCheckOptions { Predicate = registration => registration.Tags.Contains("dependencies") })); }
public void WriteResponseTest() { var err = "Some exception message"; var totalDuration = TimeSpan.FromMilliseconds(200); var httpContext = new DefaultHttpContext(); httpContext.Response.Body = new MemoryStream(); var reports = new Dictionary <string, HealthReportEntry> { { "Test1", new HealthReportEntry(HealthStatus.Healthy, "Check 1", TimeSpan.FromMilliseconds(50), null, null) }, { "Test2", new HealthReportEntry(HealthStatus.Degraded, "Check 2", TimeSpan.FromMilliseconds(45), null, null) }, { "Test3", new HealthReportEntry(HealthStatus.Unhealthy, "Check 3", TimeSpan.FromMilliseconds(50), new Exception(err), null) } }; var fullReport = new HealthReport(reports, totalDuration); HealthCheckResponseWriter.WriteResponse(httpContext, fullReport).Wait(); httpContext.Response.Body.Position = 0; using (var reader = new StreamReader(httpContext.Response.Body)) { var responseText = reader.ReadToEnd(); var options = new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, WriteIndented = true }; options.Converters.Add(new JsonStringEnumConverter()); var jsonResponse = JsonSerializer.Deserialize <HealthCheckResponse>(responseText, options); var expected = new HealthCheckResponse(fullReport); jsonResponse.Should().BeEquivalentTo(expected); } }
public Common.Models.HealthCheckResponse HealthCheck() { var response = new HealthCheckResponse(); response.Message = "Couchbase Health Check - Fail"; response.StatusCode = StatusCode.InternalServerError; response.ServiceName = ServiceNames.Cache; try { var healthCheckKey = "Couchbase.HealthCheck"; var toSave = "HealthCheck"; // Save Save(healthCheckKey, toSave, CacheRegion.Global); // Check if saved var healthCheckCacheResult = Contains <string>(healthCheckKey, CacheRegion.Global); if (healthCheckCacheResult.Exists && healthCheckCacheResult.CachedObj == toSave) { // Delete, sucess. Remove(healthCheckKey, CacheRegion.Global); response.Message = "Couchbase Health Check - Success"; response.StatusCode = StatusCode.Ok; response.ServiceName = ServiceNames.Cache; return(response); } } catch (Exception ex) { response.Message = $"Couchbase Health Check - Fail | {ex.Message},"; response.StatusCode = StatusCode.InternalServerError; response.ServiceName = ServiceNames.Cache; return(response); } // Failed return(response); }
public static Task WriteHealthCheckResponse( HttpContext httpContext, HealthReport report, Action <JsonSerializerSettings> jsonConfigurator) { var response = "{}"; if (report != null) { var settings = new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver(), NullValueHandling = NullValueHandling.Include, ReferenceLoopHandling = ReferenceLoopHandling.Ignore, }; jsonConfigurator?.Invoke(settings); settings.Converters.Add(new StringEnumConverter()); httpContext.Response.ContentType = DefaultContentType; var uiReport = HealthCheckResponse.CreateFrom(report); uiReport.Version = AssemblyVersion; response = JsonConvert.SerializeObject(uiReport, settings); } return(httpContext.Response.WriteAsync(response)); }
public async Task <ActionResult> Get() { try { var report = await this.healthCheckService.CheckHealthAsync(); var response = new HealthCheckResponse { Status = report.Status.ToString(), Checks = report.Entries.Select(x => new HealthCheck { Component = x.Key, Status = x.Value.Status.ToString(), Description = x.Value.Description, }), Duration = report.TotalDuration, }; return(report.Status == HealthStatus.Healthy ? this.Ok(response) : this.StatusCode((int)HttpStatusCode.ServiceUnavailable, response)); } catch (Exception e) { return(BadRequest(e.InnerException)); } }
private HealthCheckResponse GetHealthCheckResponse(string service, bool throwOnNotFound) { HealthCheckResponse response = null; lock (statusLock) { HealthCheckResponse.Types.ServingStatus status; if (!statusMap.TryGetValue(service, out status)) { if (throwOnNotFound) { // TODO(jtattermusch): returning specific status from server handler is not supported yet. throw new RpcException(new Status(StatusCode.NotFound, "")); } else { status = HealthCheckResponse.Types.ServingStatus.ServiceUnknown; } } response = new HealthCheckResponse { Status = status }; } return(response); }
public static void UseCustomHealthCheck(this IApplicationBuilder app) { app.UseHealthChecks("/health", new HealthCheckOptions { AllowCachingResponses = false, ResponseWriter = async(context, report) => { context.Response.ContentType = "application/json"; var response = new HealthCheckResponse { Status = report.Status.ToString(), Checks = report.Entries.Select(x => new HealthCheck { Component = x.Key, Status = x.Value.Status.ToString(), Description = x.Value.Description, Duration = x.Value.Duration.ToString() }), Duration = report.TotalDuration.ToString() }; await context.Response.WriteAsync(JsonSerializer.Serialize(response)).ConfigureAwait(true); } }); }
public async Task <HealthCheckResponse> GetHealthAsync(CancellationToken cancellationToken = default) { var healthCheckResponse = new HealthCheckResponse(); var healthChecks = ResolveDependencies(); var sw = new Stopwatch(); foreach (var task in healthChecks) { try { cancellationToken.ThrowIfCancellationRequested(); sw.Reset(); sw.Start(); var result = await task.Value.CheckHealthAsync(cancellationToken); sw.Stop(); healthCheckResponse.HealthChecks.Add(task.Key, new HealthCheckResultExtended(result) { ResponseTime = sw.ElapsedMilliseconds }); } catch (OperationCanceledException) { throw; } catch { healthCheckResponse.HealthChecks.Add(task.Key, new HealthCheckResultExtended(new HealthCheckResult(HealthStatus.Unhealthy))); } } return(healthCheckResponse); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseMigrationsEndPoint(); } else { app.UseExceptionHandler("/Error"); // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts. //app.UseHsts(); } var swaggerOptions = new SwOptions.SwaggerOptions(); Configuration.GetSection(nameof(SwaggerOptions)).Bind(swaggerOptions); app.UseSwagger(option => { option.RouteTemplate = swaggerOptions.JsonRoute; }); app.UseSwaggerUI(option => { option.SwaggerEndpoint(swaggerOptions.UIEndpoint, swaggerOptions.Description); }); app.UseHealthChecks("/health", new HealthCheckOptions { ResponseWriter = async(context, report) => { context.Response.ContentType = "application/json"; var response = new HealthCheckResponse { Status = report.Status.ToString(), Checks = report.Entries.Select(x => new HealthCheck { Component = x.Key, Status = x.Value.Status.ToString(), Description = x.Value.Description }), Duration = report.TotalDuration }; await context.Response.WriteAsync((JsonConvert.SerializeObject(response))); } }); //app.UseHttpsRedirection(); app.UseStaticFiles(); app.UseRouting(); app.UseAuthentication(); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapControllers(); }); }
static async Task Main(string[] args) { AppContext.SetSwitch( "System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true); Channel channel = new Channel("healthchecker:5000", ChannelCredentials.Insecure); Health.HealthClient client = new Health.HealthClient(channel); while (true) { try { var watch = System.Diagnostics.Stopwatch.StartNew(); HealthCheckResponse response = await client.CheckAsync(new HealthCheckRequest() { Service = "healthchecker" }); watch.Stop(); Console.WriteLine("gRPC call to Healthchecker Server took " + watch.ElapsedMilliseconds + "ms"); response.Status.ToString(); } catch (Exception ex) { Console.WriteLine(ex.Message + " " + ex.StackTrace); } System.Threading.Thread.Sleep(1000); } }
public static void InitializeHealthChecks(IApplicationBuilder app) { app.UseHealthChecks("/healthcheck", new HealthCheckOptions() { ResponseWriter = async(context, report) => { context.Response.ContentType = "application/json"; var Response = new HealthCheckResponse() { Status = report.Status.ToString(), Checks = report.Entries.Select(x => new HealthCheck { Status = x.Value.Status.ToString(), Component = x.Key, Description = x.Value.Description, Duration = x.Value.Duration }), Duration = report.TotalDuration }; await context.Response.WriteAsync( JsonConvert.SerializeObject(Response)); } }); AddSecurityToHealthCheck(app); }
public async Task <IActionResult> HealthCheck( [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "healthcheck")] HttpRequest req, ILogger log) { // list the categories try { // get the user ID if (!await this.UserAuthenticationService.GetUserIdAsync(req, out var userId, out var responseResult).ConfigureAwait(false)) { return(responseResult); } var healthCheckResponse = new HealthCheckResponse() { Status = HealthCheckStatus.OK, Application = req.Host.Host, }; return(new OkObjectResult(healthCheckResponse)); } catch (Exception ex) { log.LogError(ex, UnhandledExceptionError); throw; } }
/// <summary> /// Determines whether the specified endpoint is connected to the specified service /// that responds with health status 'Serving' . /// </summary> /// <param name="healthClient"></param> /// <param name="serviceName"></param> /// <returns>StatusCode.OK if the service is healthy.</returns> public static async Task <StatusCode> IsServingAsync( [NotNull] Health.HealthClient healthClient, [NotNull] string serviceName) { StatusCode statusCode = StatusCode.Unknown; try { HealthCheckResponse healthResponse = await healthClient.CheckAsync(new HealthCheckRequest() { Service = serviceName }); statusCode = healthResponse.Status == HealthCheckResponse.Types.ServingStatus.Serving ? StatusCode.OK : StatusCode.ResourceExhausted; } catch (RpcException rpcException) { _msg.Debug($"Error checking health of service {serviceName}", rpcException); statusCode = rpcException.StatusCode; } catch (Exception e) { _msg.Debug($"Error checking health of service {serviceName}", e); return(statusCode); } return(statusCode); }
/// <summary> /// Determines whether the specified endpoint is connected to the specified service /// that responds with health status 'Serving' . /// </summary> /// <param name="healthClient"></param> /// <param name="serviceName"></param> /// <param name="statusCode">Status code from the RPC call</param> /// <returns></returns> public static bool IsServing([NotNull] Health.HealthClient healthClient, [NotNull] string serviceName, out StatusCode statusCode) { statusCode = StatusCode.Unknown; try { HealthCheckResponse healthResponse = healthClient.Check(new HealthCheckRequest() { Service = serviceName }); statusCode = StatusCode.OK; return(healthResponse.Status == HealthCheckResponse.Types.ServingStatus.Serving); } catch (RpcException rpcException) { _msg.Debug($"Error checking health of service {serviceName}", rpcException); statusCode = rpcException.StatusCode; } catch (Exception e) { _msg.Debug($"Error checking health of service {serviceName}", e); return(false); } return(false); }
/// <summary> /// Sets the health status for given service. /// </summary> /// <param name="service">The service. Cannot be null.</param> /// <param name="status">the health status</param> public void SetStatus(string service, HealthCheckResponse.Types.ServingStatus status) { lock (myLock) { statusMap[service] = status; } }
/// <summary> /// Tries to write the health check result data into HTTP response message. /// </summary> /// <param name="httpContext">Instance of <see cref="HttpContext"/>.</param> /// <param name="result">Instance of <see cref="HealthReport"/>.</param> /// <returns>A task.</returns> public static Task WriteResponse(HttpContext httpContext, HealthReport result) { _ = httpContext ?? throw new ArgumentNullException(nameof(httpContext)); _ = result ?? throw new ArgumentNullException(nameof(result)); httpContext.Response.ContentType = "application/json"; var response = new HealthCheckResponse { Status = Enum.GetName(result.Status), HealthChecks = result.Entries.Select(pair => new HealthCheckInfo { Name = pair.Key, Report = new HealthCheckData { Status = Enum.GetName(pair.Value.Status), Description = pair.Value.Description, ElapsedMilliseconds = pair.Value.Duration.TotalMilliseconds, Tags = pair.Value.Tags, Data = pair.Value.Data } }) }; return(httpContext.Response.WriteAsync(JsonSerializer.Serialize(response, new JsonSerializerOptions { WriteIndented = true }))); }
/// <summary> /// Sets the health status for given host and service. /// </summary> /// <param name="host">The host. Cannot be null.</param> /// <param name="service">The service. Cannot be null.</param> /// <param name="status">the health status</param> public void SetStatus(string host, string service, HealthCheckResponse.Types.ServingStatus status) { lock (myLock) { statusMap[CreateKey(host, service)] = status; } }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseHsts(); } //health checks // app.UseHealthChecks("/health"); app.UseHealthChecks("/health", new HealthCheckOptions { ResponseWriter = async(context, report) => { context.Response.ContentType = "application/json"; var response = new HealthCheckResponse { Status = report.Status.ToString(), Checks = report.Entries.Select(x => new HealthCheck { Component = x.Key, Status = x.Value.Status.ToString(), Description = x.Value.Description }), Duration = report.TotalDuration }; await context.Response.WriteAsync(JsonConvert.SerializeObject(response)); } }); #region Swager#1 var swaggerOptions = new SwaggerOptions(); Configuration.GetSection(nameof(SwaggerOptions)).Bind(swaggerOptions); app.UseSwagger(options => { options.RouteTemplate = swaggerOptions.JsonRoute; }); app.UseSwaggerUI(options => { options.SwaggerEndpoint(swaggerOptions.UIEndpoint, swaggerOptions.Description); }); #endregion app.UseHttpsRedirection(); app.UseStaticFiles(); //JWT token app.UseAuthentication(); //Its Ok app.UseMvc(); }
private void MarkDelayedHealthyResponseAsWarning(HealthCheckResponse healthCheckResponse, DateTime healthCheckRequestDate) { if (healthCheckResponse.ResponseStatus.Equals(HealthCheckResponseStatus.Success) && (healthCheckResponse.MessageDate.Subtract(healthCheckRequestDate).TotalSeconds > _expectHealthResponseInSeconds)) { healthCheckResponse.ResponseStatus = HealthCheckResponseStatus.Warning; } }
public override async Task <IResponseMessage> Process(HealthCheckRequest requestMessage) { var response = new HealthCheckResponse { AgentVersion = Configuration.Version, }; return(await Task.FromResult(response)); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory) { loggerFactory.AddLog4Net(); app.Use((context, next) => { context.Features.Get <IHttpMaxRequestBodySizeFeature>().MaxRequestBodySize = null; return(next.Invoke()); }); if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } // setup api to work with proxy servers and load balancers app.UseForwardedHeaders(new ForwardedHeadersOptions { ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto }); app.UseStaticFiles(); app.UseRouting(); app.UseCors(builder => builder .AllowAnyHeader() .AllowAnyMethod() .AllowAnyOrigin() .WithExposedHeaders(tusdotnet.Helpers.CorsHelper.GetExposedHeaders().Append("upload-data").ToArray())); app.UseStorageManager(); app.UseEndpoints(endpoints => { endpoints.MapControllers(); }); app.UseHealthChecks("/health", new HealthCheckOptions { ResponseWriter = async(context, report) => { context.Response.ContentType = "application/json"; var response = new HealthCheckResponse { Status = report.Status.ToString(), Checks = report.Entries.Select(x => new HealthCheck { Component = x.Key, Status = x.Value.Status.ToString(), Description = x.Value.Description }), Duration = report.TotalDuration }; await context.Response.WriteAsync(Helpers.JsonSerialize(response)); } }); }
public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } app.UseCors(builder => builder.WithOrigins("http://localhost:4200").AllowAnyHeader().AllowAnyMethod()); app.UseHealthChecks("/health", new HealthCheckOptions { ResponseWriter = async(context, report) => { context.Response.ContentType = "application/json"; var response = new HealthCheckResponse { Status = report.Status.ToString(), Checks = report.Entries.Select(x => new HealthCheck { Component = x.Key, Status = x.Value.Status.ToString(), Description = x.Value.Description }), Duration = report.TotalDuration }; await context.Response.WriteAsync(JsonConvert.SerializeObject(response)); } }); var swaggerOptions = new SwaggerOptions(); Configuration.GetSection(nameof(SwaggerOptions)).Bind(swaggerOptions); app.UseSwagger(options => { options.RouteTemplate = swaggerOptions.JsonRoute; }); app.UseSwaggerUI(options => { options.SwaggerEndpoint(swaggerOptions.UIEndpoint, swaggerOptions.Description); }); app.UseHttpsRedirection(); app.UseRouting(); app.UseAuthorization(); app.UseAuthentication(); app.UseEndpoints(endpoints => { endpoints.MapControllers(); }); }
public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } else { app.UseExceptionHandler("/Home/Error"); app.UseHsts(); } app.UseHealthChecks("/health", new Microsoft.AspNetCore.Diagnostics.HealthChecks.HealthCheckOptions { ResponseWriter = async(context, report) => { context.Response.ContentType = "application/json"; var response = new HealthCheckResponse { Status = report.Status.ToString(), Checks = report.Entries.Select(x => new HealthCheckss { Component = x.Key, Status = x.Value.Status.ToString(), Description = x.Value.Description }), Duration = report.TotalDuration }; await context.Response.WriteAsync(JsonConvert.SerializeObject(response)); } }); app.UseHttpsRedirection(); app.UseStaticFiles(); app.UseResponseCaching(); app.UseAuthentication(); var swaggerOptions = new SwaggerOption(); Configuration.GetSection(nameof(SwaggerOptions)).Bind(swaggerOptions); //nếu k cần lấy ngay giá trị đc bind, có thể dùng app.UseSwagger(options => { options.RouteTemplate = swaggerOptions.JsonRoute; }); app.UseSwaggerUI(options => { options.SwaggerEndpoint(swaggerOptions.UIEndPoint, swaggerOptions.Description); }); app.UseMvc(); }
/// <summary> /// 健康检查报告 /// </summary> /// <param name="httpContext"></param> /// <param name="result"></param> /// <returns></returns> private static Task WriteResponse(HttpContext httpContext, HealthReport result) { httpContext.Response.ContentType = "application/json"; HealthCheckResponse healthCheckResponse = new HealthCheckResponse(result); var msg = healthCheckResponse.ToString(); return(httpContext.Response.WriteAsync(msg)); }
public async Task <HealthCheckResponse> GetHealthAsync(CancellationToken cancellationToken = default) { var healthCheckResults = new HealthCheckResponse(); var tasks = _healthChecks.Select(c => new { name = c.Key, result = c.Value.CheckHealthAsync(cancellationToken) }); var sw = new Stopwatch(); foreach (var task in tasks) { try { cancellationToken.ThrowIfCancellationRequested(); sw.Reset(); sw.Start(); var result = await task.result; sw.Stop(); healthCheckResults.Entries.Add(task.name, new HealthCheckResultExtended(result) { ResponseTime = sw.ElapsedMilliseconds }); } catch (OperationCanceledException) { throw; } catch { healthCheckResults.Entries.Add(task.name, new HealthCheckResultExtended(new HealthCheckResult(HealthStatus.Unhealthy))); } } var status = HealthStatus.Healthy; //Extrair pra classe foreach (var healthCheckResultExtended in healthCheckResults.Entries.Values) { if (healthCheckResultExtended.Status == HealthStatus.Unhealthy) { status = HealthStatus.Unhealthy; break; } if (healthCheckResultExtended.Status == HealthStatus.Degraded) { status = HealthStatus.Degraded; } } //Classe healthCheckResults.OverAllStatus = status; healthCheckResults.TotalResponseTime = healthCheckResults.Entries.Values.Sum(c => c.ResponseTime); return(healthCheckResults); }
public void ShouldReturnDegraded() { var sut = new HealthCheckResponse(); sut.Entries.Add("AnyName", HealthyResult); sut.Entries.Add("AnyAnotherName", DegradedResult); Assert.Equal(HealthStatus.Degraded, sut.OverAllStatus); }
public override async Task Watch(HealthCheckRequest request, IServerStreamWriter <HealthCheckResponse> responseStream, ServerCallContext context) { var status = GetAPIServingStatus(); var response = new HealthCheckResponse() { Status = status }; await responseStream.WriteAsync(response); }
public void IsActive() { DecidirConnector decidir = new DecidirConnector(Ambiente.AMBIENTE_SANDBOX, "", ""); HealthCheckResponse response = decidir.HealthCheck(); Assert.AreEqual(true, response.buildTime != null); Assert.AreEqual(true, response.name != null); Assert.AreEqual(true, response.version != null); }
public void ShouldSumCorrectly() { var sut = new HealthCheckResponse(); sut.Entries.Add("AnyName", HealthyResult); sut.Entries.Add("AnyAnotherName", DegradedResult); sut.Entries.Add("UnhealthyAnotherName", UnhealthyResult); Assert.Equal(3, sut.TotalResponseTime); }
public ModuleSelectionPresenter() { deviceList = new List<DeviceEntity>(); objKiosk = new monitoringProxy.DeviceEntity(); objPrinter = new monitoringProxy.DeviceEntity(); objCashAcceptor = new monitoringProxy.DeviceEntity(); objServiceResponse = new HealthCheckResponse(); IsBackendServiceConnected = InitConnectivityPolling(); pollcounter = Convert.ToInt16(string.IsNullOrWhiteSpace(ConfigurationManager.AppSettings["PUSHMONITORINGUPDATECOUNT"]) ? "10" : ConfigurationManager.AppSettings["PUSHMONITORINGUPDATECOUNT"]); //if (bool.Parse(ConfigurationManager.AppSettings["StandAloneMode"]) == false) // IsBackendServiceConnected = InitConnectivityPolling(); //else // IsBackendServiceConnected = true; }