public async Task JenkinsView_Should_NOT_DuplicateJobs_When_Refreshing() { var logger = Substitute.For <ILogger>(); var folder = new Folder(); var jenkinsView = new JenkinsView_v1 { Name = "Jenkins View", Interval = 0, URL = @"https://jenkins.mono-project.com/view/Urho/", IgnoreSslErrors = true }; folder.Add(jenkinsView); var handler = new JenkinsViewStatus(logger); var request = HealthCheckRequest.Create(jenkinsView); await handler.Handle(request, CancellationToken.None); Assert.IsNotNull(jenkinsView.Items); Assert.IsTrue(jenkinsView.Items.Any()); var count = jenkinsView.Items.Count; await handler.Handle(request, CancellationToken.None); Assert.AreEqual(count, jenkinsView.Items.Count); }
public async Task Handle(HealthCheckRequest <JenkinsView_v1> request, CancellationToken cancellationToken) { var jenkinsClient = new JenkinsClient(_logger); var jenkinsViewResponse = await jenkinsClient.GetViewAsync(request.DataContext).ConfigureAwait(false); var prevJobs = request.DataContext.Items.OfType <JenkinsJob_v1>(); var dispatcher = Application.Current != null ? Application.Current.Dispatcher : Dispatcher.CurrentDispatcher; dispatcher.Invoke(() => { // Add Jobs var newJobs = jenkinsViewResponse.Jobs.Where(x => prevJobs.All(y => y.URL != x.URL)).OrderBy(x => x.Name); foreach (var job in newJobs) { AddJob(request.DataContext, job); } // Remove Jobs foreach (var job in prevJobs.Where(x => jenkinsViewResponse.Jobs.All(y => y.URL != x.URL))) { request.DataContext.Remove(job); } }); }
public override Task <HealthCheckResponse> Check(HealthCheckRequest request, ServerCallContext context) { return(Task.FromResult(new HealthCheckResponse { Status = HealthCheckResponse.Types.ServingStatus.Serving })); }
public async Task Handle(HealthCheckRequest <VSTSBuild_v1> request, CancellationToken cancellationToken) { var vsts = new VSTS(); request.DataContext.MapTo(vsts); if (request.DataContext.DefinitionId == null) { var definition = await vsts.GetBuildDefinitionAsync(request.DataContext.DefinitionName).ConfigureAwait(false); request.DataContext.DefinitionId = definition.Id; } var builds = await vsts.Request <Collection <VSTSBuild> >($"build/builds?definitions={request.DataContext.DefinitionId}&$top=1&api-version=2.0").ConfigureAwait(false); var build = builds?.Value?.FirstOrDefault(); if (build != null) { request.DataContext.State = build.State; } else { request.DataContext.State = State.Unknown; _logger.Error($"VSTS build definition \"{request.DataContext.DefinitionName}\" no builds were found."); } }
public async Task Handle(HealthCheckRequest <JenkinsJob_v1> request, CancellationToken cancellationToken) { var jenkinsClient = new JenkinsClient(_logger); var jenkinsJob = await jenkinsClient.GetJobAsync(request.DataContext).ConfigureAwait(false); if (jenkinsJob.IsRunning) { OnBuildRunning(request.DataContext, jenkinsJob.Executor.Progress); return; } if (request.DataContext.ProgressEnabled) { request.DataContext.ProgressEnabled = false; request.DataContext.Progress = 0; } if (jenkinsJob.Result == null) { throw new Exception("Jenkins job result is null."); } request.DataContext.State = ConvertBuildResultToState(jenkinsJob.Result); }
public async Task Handle(HealthCheckRequest <IndexHealthWidget> request, CancellationToken cancellationToken) { var indexHealthWidget = request.DataContext; var client = elasticsearchHelper.GetElasticClient(indexHealthWidget); var indexHealthResponse = await client.IndexHealthAsync(indexHealthWidget.IndexName, cancellationToken); if (indexHealthResponse.IsValid) { switch (indexHealthResponse.Status) { case ElasticsearchClient.Objects.Shared.Health.Green: indexHealthWidget.State = State.Ok; break; case ElasticsearchClient.Objects.Shared.Health.Yellow: indexHealthWidget.State = State.PartiallySucceeded; break; default: indexHealthWidget.State = State.Failed; break; } } else { indexHealthWidget.State = State.Invalid; } }
public override async Task <HealthCheckResponse> Check(HealthCheckRequest request, ServerCallContext context) { return(new HealthCheckResponse() { Status = HealthCheckResponse.Types.ServingStatus.Serving }); }
public override Task <HealthCheckResponse> Check(HealthCheckRequest request, ServerCallContext context) { logger.Debug("Checking CartService Health"); return(Task.FromResult(new HealthCheckResponse { Status = dependency.Ping() ? HealthCheckResponse.Types.ServingStatus.Serving : HealthCheckResponse.Types.ServingStatus.NotServing })); }
public async Task Handle(HealthCheckRequest <PoliciesWidget> request, CancellationToken cancellationToken) { var ctx = request.DataContext; var client = new RabbitMqClient(ctx.URL, ctx.Username, ctx.Password); try { var policies = await client.GetPoliciesAsync(ctx.PoliciesUrlPath, ctx.VirtualHost).ConfigureAwait(false); var missedPolicies = new List <string>(); foreach (var requiredPolicy in ctx.RequiredPolicies) { if (!policies.Any(x => x.Name == requiredPolicy)) { missedPolicies.Add(requiredPolicy); } } if (missedPolicies.Any()) { ctx.Message = "Missed policies: " + string.Join(", ", missedPolicies); ctx.State = State.Failed; } else { ctx.State = State.Ok; } } catch (Exception e) { ctx.Message = e.Message; ctx.State = State.Failed; } }
public override Task <HealthCheckResponse> HealthCheck(HealthCheckRequest request, ServerCallContext context) { return(Task.FromResult(new HealthCheckResponse() { Status = ResponseFactory.createResponse(ResponseType.SUCCESS), })); }
protected override void HandleCore(HealthCheckRequest <PowerShellScript> request) { if (!File.Exists(request.DataContext.FileName)) { throw new FileNotFoundException(request.DataContext.FileName); } var executionPolicy = request.DataContext.BypassExecutionPolicy ? "ByPass" : "Restricted"; var info = new ProcessStartInfo { FileName = "PowerShell.exe", Arguments = $"-ExecutionPolicy {executionPolicy} -File \"{request.DataContext.FileName}\" {request.DataContext.Arguments}", CreateNoWindow = true, ErrorDialog = false, LoadUserProfile = false, WindowStyle = ProcessWindowStyle.Hidden, UseShellExecute = false, RedirectStandardOutput = true, }; var exitCode = _processStarter.Start(info, TimeSpan.FromMinutes(request.DataContext.Timeout)); request.DataContext.State = exitCode == 0 ? State.Ok : State.Failed; }
public async Task AddMonitorPulse(HealthCheckRequest healthCheckRequest) { await _monitorCounterRepository.AddAsync(new MonitorCounter { Id = DataUtil.GenerateUniqueId(), BeatDate = healthCheckRequest.BeatDate.ToDateTime(), ServiceId = healthCheckRequest.ServiceId, ServiceName = healthCheckRequest.ServiceName, HttpCounter = new HttpCounter { AvgDuration = Math.Round(healthCheckRequest.HttpHealthCheck.AvgDuration, 0, MidpointRounding.AwayFromZero), FailedRequests = healthCheckRequest.HttpHealthCheck.FailedRequests, MeansureDate = healthCheckRequest.BeatDate.ToDateTime(), SuccessRequests = healthCheckRequest.HttpHealthCheck.SuccessRequests, TotalRequestsPerDay = healthCheckRequest.HttpHealthCheck.TotalRequestsPerDay, ServiceId = healthCheckRequest.ServiceId }, HardwareCounter = new HardwareCounter { CpuUsage = Math.Round(healthCheckRequest.HardwareInfoHealthCheck.CpuUsage, 0, MidpointRounding.AwayFromZero), MemoryUsed = healthCheckRequest.HardwareInfoHealthCheck.MemoryUsed, MemoryUsedInMb = (int)Math.Round((double)(healthCheckRequest.HardwareInfoHealthCheck.MemoryUsed / 1024), 0, MidpointRounding.AwayFromZero), IsCpuBottleneck = healthCheckRequest.HardwareInfoHealthCheck.IsCpuBottleNeck, IsMemoryThreshold = healthCheckRequest.HardwareInfoHealthCheck.IsMemoryThreshold, MeansureDate = healthCheckRequest.BeatDate.ToDateTime(), ServiceId = healthCheckRequest.ServiceId } }); }
public override Task Watch(HealthCheckRequest request, IServerStreamWriter <HealthCheckResponse> responseStream, ServerCallContext context) { responseStream.WriteAsync(new HealthCheckResponse { Status = ServingStatus.Serving }); return(Task.CompletedTask); }
public override async Task <HealthCheckResponse> Check(HealthCheckRequest request, ServerCallContext context) { HealthReport healthReport; if (string.IsNullOrWhiteSpace(request.Service)) { healthReport = await _healthCheckService.CheckHealthAsync(); } else { healthReport = await _healthCheckService.CheckHealthAsync( s => string.Equals(s.Name, request.Service, StringComparison.OrdinalIgnoreCase)); if (healthReport.Entries.Count == 0) { throw new RpcException(new Status(StatusCode.NotFound, $"Service {request.Service} not found")); } } _logger.LogInformation("HealthReport {@HealthReport}", healthReport); return(new HealthCheckResponse { Status = healthReport.Status switch { HealthStatus.Degraded => HealthCheckResponse.Types.ServingStatus.Serving, HealthStatus.Healthy => HealthCheckResponse.Types.ServingStatus.Serving, HealthStatus.Unhealthy => HealthCheckResponse.Types.ServingStatus.NotServing, _ => HealthCheckResponse.Types.ServingStatus.Unknown, } });
public async Task Handle(HealthCheckRequest <BuildWidget> request, CancellationToken cancellationToken) { var widget = request.DataContext; var api = new AzureDevOpsApi(widget.ConnectionSettings); var results = await api.GetBuildsAsync(widget.Project, widget.DefinitionId, 10, cancellationToken).ConfigureAwait(false); if (results.Count == 0) { widget.State = State.None; return; } var builds = results.Value.ToList(); UpdateInfo(widget, builds[0]); UpdateStats(widget, builds); builds.Reverse(); UpdateHistory(widget, builds); }
public void CheckServiceHealth_ShouldBeHealthy() { HealthCheckRequest request = new HealthCheckRequest(); Console.WriteLine($"Calling Health Check..."); try { _jsonClient.Get(request); } catch (WebServiceException ex) { IEnumerable <string> unresolvedDependencies = ex.ResponseStatus?.Errors?.Select(responseError => responseError.Message); if (unresolvedDependencies != null && unresolvedDependencies.Any()) { Console.WriteLine($"Found {unresolvedDependencies.Count()} unresolved dependencies"); foreach (string unresolvedDependency in unresolvedDependencies) { Console.WriteLine($"Dependency that was unresolved: {unresolvedDependency}"); } Assert.IsTrue(false); } else { Console.WriteLine($"Health check failed but no unresolved dependencies were found"); Assert.IsTrue(false); } return; } Console.WriteLine("Healthy Health Check Returned."); Assert.IsTrue(true); }
static void Main(string[] args) { Console.WriteLine("Press any key to start the check."); Console.ReadKey(true); var channel = GrpcChannel.ForAddress("https://localhost:5001"); var client = new Health.HealthClient(channel); var req = new HealthCheckRequest { Service = "Liveness" }; try { var res = client.Check(req); Console.WriteLine(res.Status); } catch (Exception ex) { Console.WriteLine(ex.Message); } Console.ReadKey(true); }
public async Task Handle(HealthCheckRequest <VSTSRelease_v1> request, CancellationToken cancellationToken) { var widget = request.DataContext ?? throw new InvalidOperationException(); var client = new VstsClient(); widget.MapTo(client); if (widget.ReleaseId == null) { var definition = await client .GetReleaseDefinitionAsync(widget.ReleaseDefinitionName) .ConfigureAwait(false); widget.ReleaseId = definition.Id; } var lastRelease = await client .GetLastReleaseAsync(widget.ReleaseId.Value) .ConfigureAwait(false); var releaseDetails = await client .GetReleaseDetailsAsync(lastRelease.Id) .ConfigureAwait(false); RemoveEnvironments(widget, releaseDetails.Environments); AddEnvironments(widget, releaseDetails); }
public override async Task Watch(HealthCheckRequest request, IServerStreamWriter <HealthCheckResponse> responseStream, ServerCallContext context) { var servcieName = request.Service; await responseStream.WriteAsync((new HealthCheckResponse { Status = HealthCheckResponse.Types.ServingStatus.Serving })); }
public async Task Handle(HealthCheckRequest <ReleaseWidget> request, CancellationToken cancellationToken) { var widget = request.DataContext; var api = new AzureDevOpsApi(widget.ConnectionSettings); var releases = await api.GetReleasesAsync(widget.Project, widget.DefinitionId, 1, cancellationToken).ConfigureAwait(false); if (releases.Count == 0) { widget.State = State.None; return; } var release = releases.Value.First(); UpdateInfo(widget, release); _uiAction.Invoke(() => UpdateEnvironments(widget, release)); var deployments = await api.GetDeploymentsAsync(widget.Project, widget.DefinitionId, 10, cancellationToken).ConfigureAwait(false); if (deployments.Count > 0) { UpdateHistory(widget, deployments.Value.ToList()); } }
public async Task ClusterHealthShouldInvalidWhenResponseIsInvalid() { var widget = new ClusterHealthWidget { NodeUris = new List <string>() { "http://127.0.0.1:9200" } }; var clusterHealthResponseMock = new Mock <ClusterHealthResponse>(); var elasticsearchHelperMock = new Mock <ElasticsearchHelper>(); var elasticsearchSimpleClientMock = new Mock <ElasticsearchSimpleClient>(MockBehavior.Strict, new object[] { widget }); clusterHealthResponseMock.Setup(response => response.IsValid).Returns(false); elasticsearchHelperMock.Setup(helper => helper.GetElasticClient(It.IsAny <IElasticsearchWidget>())) .Returns(elasticsearchSimpleClientMock.Object); elasticsearchSimpleClientMock.Setup(client => client.HealthAsync(It.IsAny <CancellationToken>())) .Returns(Task.FromResult(clusterHealthResponseMock.Object)); var request = HealthCheckRequest.Create(widget); var handler = new ClusterHealthCheck(elasticsearchHelperMock.Object); await handler.Handle(request, CancellationToken.None).ConfigureAwait(false); Assert.AreEqual(State.Invalid, request.DataContext.State); elasticsearchHelperMock.Verify(client => client.GetElasticClient(It.IsAny <IElasticsearchWidget>()), Times.Once()); elasticsearchSimpleClientMock.Verify(client => client.HealthAsync(It.IsAny <CancellationToken>()), Times.Once()); }
public async Task IndexHealthShouldPartiallySucceededWhenClusterStatusYellow() { var widget = new IndexHealthWidget { NodeUris = new List <string>() { "http://127.0.0.1:9200" }, IndexName = indexName }; var indexHealthResponseMock = new Mock <IndexHealthResponse>(); var elasticsearchHelperMock = new Mock <ElasticsearchHelper>(); var elasticsearchSimpleClientMock = new Mock <ElasticsearchSimpleClient>(MockBehavior.Strict, new object[] { widget }); indexHealthResponseMock.Setup(response => response.IsValid).Returns(true); indexHealthResponseMock.Setup(response => response.Status).Returns(Health.Yellow); elasticsearchHelperMock.Setup(helper => helper.GetElasticClient(It.IsAny <IElasticsearchWidget>())) .Returns(elasticsearchSimpleClientMock.Object); elasticsearchSimpleClientMock.Setup(client => client.IndexHealthAsync(indexName, It.IsAny <CancellationToken>())) .Returns(Task.FromResult(indexHealthResponseMock.Object)); var request = HealthCheckRequest.Create(widget); var handler = new IndexHealthCheck(elasticsearchHelperMock.Object); await handler.Handle(request, CancellationToken.None).ConfigureAwait(false); Assert.AreEqual(State.PartiallySucceeded, request.DataContext.State); elasticsearchHelperMock.Verify(client => client.GetElasticClient(It.IsAny <IElasticsearchWidget>()), Times.Once()); elasticsearchSimpleClientMock.Verify(client => client.IndexHealthAsync(indexName, It.IsAny <CancellationToken>()), Times.Once()); }
public override async Task Watch(HealthCheckRequest request, IServerStreamWriter <HealthCheckResponse> responseStream, ServerCallContext context) { await responseStream.WriteAsync(new HealthCheckResponse() { Status = HealthCheckResponse.Types.ServingStatus.Serving }); }
public override Task <HealthCheckResponse> Check(HealthCheckRequest request, ServerCallContext context) { Console.WriteLine("Checking CartService Health"); return(Task.FromResult(new HealthCheckResponse { Status = _cartStore.Ping() ? HealthCheckResponse.Types.ServingStatus.Serving : HealthCheckResponse.Types.ServingStatus.NotServing })); }
public async Task Handle(HealthCheckRequest <BcHttpStatus> request, CancellationToken cancellationToken) { using (var handler = new HttpClientHandler()) { //if (!string.IsNullOrWhiteSpace(request.DataContext.CertificateFile)) { // X509Certificate2 certificate; // if (string.IsNullOrWhiteSpace(request.DataContext.CertificatePassword)) { // certificate = new X509Certificate2(request.DataContext.CertificateFile); // } else // { // certificate = new X509Certificate2(request.DataContext.CertificateFile, request.DataContext.CertificatePassword); // } // handler.ClientCertificateOptions = ClientCertificateOption.Automatic; //} handler.ClientCertificateOptions = ClientCertificateOption.Automatic; try { using (var client = new HttpClient(handler)) { var response = await client.GetAsync(request.DataContext.Url).ConfigureAwait(false); var responseBody = await response.Content.ReadAsStringAsync(); if (request.DataContext.IsHealthCheck) { var result = JsonConvert.DeserializeObject <HealthCheckResult>(responseBody); request.DataContext.State = result.allChecksPassed ? State.Ok : State.Failed; if (!result.allChecksPassed) { throw new Exception("Error in Health Check: " + responseBody); } } else { request.DataContext.State = response.IsSuccessStatusCode ? State.Ok : State.Failed; if (!response.IsSuccessStatusCode) { throw new Exception("Error in request: " + responseBody); } } } } catch (AggregateException ae) { ae.Handle(ex => { if (ex is HttpRequestException) { request.DataContext.State = State.Failed; } return(ex is HttpRequestException); }); } } }
public async Task API_HealthCheckTest() { var widget = new TestWidget(); var handler = new CheckHealth(); var request = HealthCheckRequest.Create(widget); await handler.Handle(request, CancellationToken.None); }
public override Task <HealthCheckResponse> Check(HealthCheckRequest request, ServerCallContext context) { //TODO:检查逻辑 return(Task.FromResult(new HealthCheckResponse() { Status = ServingStatus.Serving })); }
public void PushHealthCheck(HealthCheckRequest healthCheckRequest) { healthCheckRequest.ServiceId = serviceId; healthCheckRequest.ServiceName = _selfOptions.ServerName; var monitorTask = _monitorProvider.AddMonitorPulse(healthCheckRequest); monitorTask.Wait(); }
public void ServiceIsRunning() { serviceImpl.SetStatus("", "", HealthCheckResponse.Types.ServingStatus.SERVING); var response = client.Check(HealthCheckRequest.CreateBuilder().SetHost("").SetService("").Build()); Assert.AreEqual(HealthCheckResponse.Types.ServingStatus.SERVING, response.Status); }
public HealthCheckResponse Check(HealthCheckRequest request) { Console.WriteLine("Checking CartService Health"); return(new HealthCheckResponse { Status = dependency.Ping() ? HealthCheckResponse.Types.ServingStatus.Serving : HealthCheckResponse.Types.ServingStatus.NotServing }); }
public Task<HealthCheckResponse> Check(HealthCheckRequest request, ServerCallContext context) { lock (myLock) { var host = request.HasHost ? request.Host : ""; var service = request.HasService ? request.Service : ""; HealthCheckResponse.Types.ServingStatus status; if (!statusMap.TryGetValue(CreateKey(host, service), out status)) { // TODO(jtattermusch): returning specific status from server handler is not supported yet. throw new RpcException(new Status(StatusCode.NotFound, "")); } return Task.FromResult(HealthCheckResponse.CreateBuilder().SetStatus(status).Build()); } }
/// <summary> /// Performs a health status check. /// </summary> /// <param name="request">The check request.</param> /// <param name="context">The call context.</param> /// <returns>The asynchronous response.</returns> public override Task<HealthCheckResponse> Check(HealthCheckRequest request, ServerCallContext context) { lock (myLock) { var service = request.Service; HealthCheckResponse.Types.ServingStatus status; if (!statusMap.TryGetValue(service, out status)) { // TODO(jtattermusch): returning specific status from server handler is not supported yet. throw new RpcException(new Status(StatusCode.NotFound, "")); } return Task.FromResult(new HealthCheckResponse { Status = status }); } }