private async Task insertContainerMetric(BenchmarkExperiment appTest)
{
var metricStat = new ContainerMetric();
IProgress <ContainerStatsResponse> progress = new Progress <ContainerStatsResponse>(stats =>
{
//var json = JsonConvert.SerializeObject(stats);
metricStat.ContainerId = appTest.AppContainerId;
metricStat.ContainerName = appTest.DockerFriendlyName;
metricStat.DateTimeCreated = DateTime.UtcNow;
metricStat.DockerDateTimestamp = stats.Read;
//JsonDockerResponse = json,
metricStat.BenchmarkExperiment = appTest;
metricStat.MemoryLimit = stats.MemoryStats.Limit;
metricStat.MemoryUsage = stats.MemoryStats.Usage;
metricStat.SetCPUPercentage(stats.CPUStats, stats.PreCPUStats);
metricStat.CalculateNetworks(stats.Networks);
metricStat.CalculateBlockIO(stats.BlkioStats);
//testList.Add(metricStat);
});
await _dockerAppClient.Containers.GetContainerStatsAsync(appTest.AppContainerId, new ContainerStatsParameters { Stream = false }, progress, CancellationToken.None);
await _containerMetricRepo.AddAsync(metricStat);
}
private IEnumerable <BenchmarkTestItemViewModel> GetWebServerBenchmarkData(BenchmarkExperiment application)
{
var webserverData = application.TestResults;
var apiModel = _mapper.Map <IEnumerable <BenchmarkTestItemViewModel> >(webserverData).OrderBy(c => c.Timestamp);
return(apiModel);
}
private IEnumerable <DockerStatsApiModel> GetDockerApiStats(BenchmarkExperiment application)
{
var benchmarkStartTime = application.StartedAt.UtcDateTime;
var benchmarkEndTime = application.CompletedAt.UtcDateTime;
var containerMetrics = application.ContainerMetrics;
var cpuMetrics = containerMetrics.Where(c => (c.DateTimeCreated.UtcDateTime >= benchmarkStartTime && c.DateTimeCreated.UtcDateTime <= benchmarkEndTime)).ToList();
var apiModel = _mapper.Map <IEnumerable <DockerStatsApiModel> >(cpuMetrics).OrderBy(c => c.DateTimeUtc);
return(apiModel);
}
private async Task saveExperimentCSVToDatabase(IFormFile formFile, BenchmarkExperiment experiment)
{
Guard.Against.Null(formFile, nameof(formFile));
Guard.Against.Null(experiment, nameof(experiment));
string csvBase64 = await formFileToBase64(formFile);
if (csvBase64 != null)
{
experiment.CSVResultsFile = csvBase64;
await _benchmarkExperimentRepo.UpdateAsync(experiment);
}
throw new Exception("Error cannot save file to database.");
}
private async Task <string> LaunchBenchmarkToHost(BenchmarkExperiment appTest)
{
Guard.Against.Null(appTest, nameof(appTest));
if (appTest.BenchmarkHost == null)
{
throw new NullReferenceException("Benchmark Host is null for Application Test");
}
if (appTest.Application.BenchmarkingImage == null)
{
throw new NullReferenceException("BenchmarkingImage is null for Application.");
}
if (appTest.BenchmarkHost.UseHttpAuthentication)
{
CreateBasicHttpClient(appTest.BenchmarkHost.HostName, appTest.BenchmarkHost.PortNumber, appTest.BenchmarkHost.UserName, appTest.BenchmarkHost.Password, out _dockerBenchmarkClient);
}
else
{
CreateClientNoAuthentication(appTest.BenchmarkHost.HostName, appTest.BenchmarkHost.PortNumber, out _dockerBenchmarkClient);
}
await RemoveContainersFromHost(_dockerBenchmarkClient);
await PullImageOntoHost(appTest.Application.BenchmarkingImage, HostType.Benchmark);
Uri uri = new Uri(_hostSettings.CurrentHost);
uri.SetPort(_hostSettings.CurrentPort);
//Get Hostname and Port for Jmeter Parameters.
string testPlanUrl = BuildJMXPath(uri.AbsoluteUri, appTest.Id);
string uriHost = uri.Host;
var environmentalVariablesList = new List <string>();
foreach (var variable in appTest.Application.BenchmarkingImage.Variables)
{
var variableString = variable.Name + "=" + variable.Value;
environmentalVariablesList.Add(variableString);
}
environmentalVariablesList.Add("JMETER_TEST_PLAN=" + testPlanUrl);
environmentalVariablesList.Add("JMETER_TEST_OUTPUT=" + appTest.Id.ToString());
return(await CreateContainerOntoHost(appTest.Application.BenchmarkingImage, environmentalVariablesList, _dockerBenchmarkClient));
}
public async Task <bool> EndBenchmarkExperiment(BenchmarkExperiment benchmarkExperiment)
{
Guard.Against.Null(benchmarkExperiment, nameof(benchmarkExperiment));
benchmarkExperiment.Completed = true;
benchmarkExperiment.CompletedAt = DateTimeOffset.UtcNow;
await _appTestRepo.UpdateAsync(benchmarkExperiment);
await SetHostToInactive(benchmarkExperiment.Host);
await SetHostToInactive(benchmarkExperiment.BenchmarkHost);
if (benchmarkExperiment.DatabaseHost != null)
{
await SetHostToInactive(benchmarkExperiment.BenchmarkHost);
}
_backgroungJobClient.Delete(benchmarkExperiment.HangfireContainerMetricsJobId);
await ProcessDockerStats(benchmarkExperiment.Id);
return(true);
}
//Not Required.
public async Task <bool> StartBenchmarkingStep2(BenchmarkExperiment benchmarkExperiment)
{
Guard.Against.Null(benchmarkExperiment, nameof(benchmarkExperiment));
benchmarkExperiment.Started = true;
benchmarkExperiment.StartedAt = DateTimeOffset.UtcNow;
await _appTestRepo.UpdateAsync(benchmarkExperiment);
if (benchmarkExperiment.CaptureContainerMetrics)
{
//Capture Docker Stats in Background Job so it's not blocking confirmation to the user.
//var jobId = BackgroundJob.Enqueue(() => CaptureDockerStatsAsync(benchmarkExperiment.Id));
var jobId = _backgroungJobClient.Enqueue(() => CaptureDockerStatsAsync(benchmarkExperiment.Id, JobCancellationToken.Null));
//_backgroungJobClient.ContinueWith(jobId, () => ProcessDockerStats(benchmarkExperiment.Id));
benchmarkExperiment.HangfireContainerMetricsJobId = jobId;
await _appTestRepo.UpdateAsync(benchmarkExperiment);
}
return(true);
}
public ExperimentFinishedEvent(BenchmarkExperiment experiment)
{
Experiment = experiment;
}
public bool CaptureDockerStats(BenchmarkExperiment appTest)
{
throw new NotImplementedException();
}
//TODO public Task <bool> StopApplicationContainer(BenchmarkExperiment appTest) => throw new NotImplementedException();
private async Task SendDeleteResourcesRequests(BenchmarkExperiment experiment)
{
Guard.Against.Null(experiment, nameof(experiment));
if (experiment.Host.AzureHost != null)
{
if (experiment.Host.AzureHost.DestroyResourcesAfterBenchmark)
{
experiment.Host.Active = false;
_backgroungJobClient.Enqueue <IAzureResourceService>(c => c.DeleteResources(experiment.Host.AzureHost.Id));
}
}
if (experiment.Host.AWSHost != null)
{
if (experiment.Host.AWSHost.DestroyResourcesAfterBenchmark)
{
experiment.Host.Active = false;
_backgroungJobClient.Enqueue <IAWSHostService>(c => c.DeleteResourcesAfterExperiment(experiment.Host.AWSHost.Id));
}
}
if (experiment.BenchmarkHost.AzureHost != null)
{
if (experiment.BenchmarkHost.AzureHost.DestroyResourcesAfterBenchmark)
{
experiment.BenchmarkHost.Active = false;
_backgroungJobClient.Enqueue <IAzureResourceService>(c => c.DeleteResources(experiment.BenchmarkHost.AzureHost.Id));
}
}
if (experiment.BenchmarkHost.AWSHost != null)
{
if (experiment.BenchmarkHost.AWSHost.DestroyResourcesAfterBenchmark)
{
experiment.BenchmarkHost.Active = false;
_backgroungJobClient.Enqueue <IAWSHostService>(c => c.DeleteResourcesAfterExperiment(experiment.BenchmarkHost.AWSHost.Id));
}
}
if (experiment.DatabaseHost != null)
{
if (experiment.DatabaseHost.AzureHost != null)
{
if (experiment.DatabaseHost.AzureHost.DestroyResourcesAfterBenchmark)
{
experiment.DatabaseHost.Active = false;
_backgroungJobClient.Enqueue <IAzureResourceService>(c => c.DeleteResources(experiment.DatabaseHost.AzureHost.Id));
}
}
if (experiment.DatabaseHost.AWSHost != null)
{
if (experiment.DatabaseHost.AWSHost.DestroyResourcesAfterBenchmark)
{
experiment.DatabaseHost.Active = false;
_backgroungJobClient.Enqueue <IAWSHostService>(c => c.DeleteResourcesAfterExperiment(experiment.DatabaseHost.AWSHost.Id));
}
}
}
await _benchmarkExperimentRepo.UpdateAsync(experiment);
}
