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