private void CheckWorkersAvailability(object sender, ElapsedEventArgs eventArgs)
{
var workers = ImageWorkerRepository.Instance.FindAll().ToList();
if (workers == null || !workers.Any())
{
return;
}
foreach (var imageWorker in workers)
{
try
{
var restImageProcessorClient = new RestImageProcessorClient(imageWorker.WorkerServiceUrl);
restImageProcessorClient.SetKeplerServiceUrl();
imageWorker.WorkerStatus = ImageWorker.StatusOfWorker.Available;
}
catch (Exception ex)
{
ErrorMessageRepository.Instance.Insert(new ErrorMessage()
{
ExceptionMessage = $"Image worker: '{imageWorker.Name}' is unavailable. {ex.Message}"
});
imageWorker.WorkerStatus = ImageWorker.StatusOfWorker.Offline;
}
finally
{
ImageWorkerRepository.Instance.Update(imageWorker);
}
}
}
public void UpdateKeplerServiceUrlOnWorkers()
{
var workers = ImageWorkerRepository.Instance.FindAll()
.Where(worker => worker.WorkerStatus == ImageWorker.StatusOfWorker.Available).ToList();
foreach (var imageWorker in workers)
{
var restImageProcessorClient = new RestImageProcessorClient(imageWorker.WorkerServiceUrl);
restImageProcessorClient.SetKeplerServiceUrl();
}
}
public void RegisterImageWorker(string name, string imageWorkerServiceUrl)
{
imageWorkerServiceUrl = imageWorkerServiceUrl.Trim();
var workerRepo = ImageWorkerRepository.Instance;
if (!workerRepo.Find(new { Name = imageWorkerServiceUrl }).Any())
{
workerRepo.Insert(new ImageWorker
{
Name = name,
WorkerServiceUrl = imageWorkerServiceUrl
});
var restImageWorkerClient = new RestImageProcessorClient(imageWorkerServiceUrl);
restImageWorkerClient.SetKeplerServiceUrl();
}
else
{
LogErrorMessage(ErrorMessage.ErorCode.NotUniqueObjects,
$"Image worker with the same URL {imageWorkerServiceUrl} already exist");
}
}
private void SendComparisonInfoToWorkers(object sender, ElapsedEventArgs eventArgs)
{
// if there is already executing build
if (BuildRepository.Instance.GetBuildsByStatus(ObjectStatus.InProgress).Any())
{
return;
}
var workers = ImageWorkerRepository.Instance.FindAll()
.Where(worker => worker.WorkerStatus == ImageWorker.StatusOfWorker.Available).ToList();
if (workers.Count == 0)
{
return;
}
var buildInQueue = BuildRepository.Instance.GetBuildsByStatus(ObjectStatus.InQueue).FirstOrDefault();
if (buildInQueue == null)
{
return;
}
var screenShots = ScreenShotRepository.Instance.GetInQueueScreenShotsForBuild(buildInQueue.Id);
screenShots.Each(item => item.Status = ObjectStatus.InProgress);
ScreenShotRepository.Instance.Update(screenShots);
UpdateObjectStatusesScheduler.GetScheduler.Invoke();
var imageComparisonContainers = ConvertScreenShotsToImageComparison(screenShots).ToList();
// split all screenshots for comparison uniformly for all workers
var imgComparisonPerWorker = imageComparisonContainers.Count() / workers.Count();
if (imgComparisonPerWorker == 0)
{
imgComparisonPerWorker = imageComparisonContainers.Count();
}
var workerIndex = 0;
while (imageComparisonContainers.Any())
{
var jsonMessage = new ImageComparisonContract()
{
ImageComparisonList = imageComparisonContainers.Take(imgComparisonPerWorker).ToList()
};
var requestIsSuccessfull = true;
try
{
var client = new RestClient(workers[workerIndex++].WorkerServiceUrl);
var request = new RestRequest("AddImagesForDiffGeneration", Method.POST);
request.RequestFormat = DataFormat.Json;
request.AddJsonBody(jsonMessage);
var response = client.Execute(request);
var responseErrorMessage = RestImageProcessorClient.GetResponseErrorMessage(response);
if (!String.IsNullOrEmpty(responseErrorMessage))
{
throw new WebException(responseErrorMessage);
}
}
catch (Exception ex)
{
requestIsSuccessfull = false;
ErrorMessageRepository.Instance.Insert(new ErrorMessage()
{
ExceptionMessage =
$"Error happend when process is tried to send images for comparison to worker: '{workers[workerIndex++].Name}'. {ex.Message} {ex.StackTrace}"
});
}
if (requestIsSuccessfull)
{
if (imageComparisonContainers.Count() < imgComparisonPerWorker)
{
imageComparisonContainers.Clear();
}
else
{
imageComparisonContainers.RemoveRange(0, imgComparisonPerWorker);
}
}
if (workerIndex == workers.Count)
{
workerIndex = 0;
}
}
}
public void RunOperation(string typeName, long objId, string operationName)
{
switch (operationName.ToLowerInvariant())
{
case "run":
try
{
ObjectStatusUpdater.SetObjectsStatus(typeName, objId, ObjectStatus.InQueue);
if (typeName == "build")
{
return;
}
long?buildId = -1;
switch (typeName.ToLowerInvariant())
{
case "screenshot":
var screenShot = ScreenShotRepository.Instance.Get(objId);
buildId = screenShot.BuildId;
var caseRepo = TestCaseRepository.Instance;
ObjectStatusUpdater.SetParentObjStatus <TestCaseRepository, TestCase>(
caseRepo, screenShot.ParentObjId.Value, ObjectStatus.InQueue);
var suiteId = caseRepo.Get(screenShot.ParentObjId.Value).ParentObjId.Value;
var repoSuite = TestSuiteRepository.Instance;
ObjectStatusUpdater.SetParentObjStatus <TestSuiteRepository, TestSuite>(
repoSuite, suiteId, ObjectStatus.InQueue);
var assembId = repoSuite.Get(suiteId).ParentObjId.Value;
ObjectStatusUpdater.SetParentObjStatus <TestAssemblyRepository, TestAssembly>(
TestAssemblyRepository.Instance, assembId, ObjectStatus.InQueue);
break;
case "testcase":
var testCase = TestCaseRepository.Instance.Get(objId);
buildId = testCase.BuildId;
var suiteRepo = TestSuiteRepository.Instance;
ObjectStatusUpdater.SetParentObjStatus <TestSuiteRepository, TestSuite>(
suiteRepo, testCase.ParentObjId.Value, ObjectStatus.InQueue);
var assemblyId = suiteRepo.Get(testCase.ParentObjId.Value).ParentObjId.Value;
ObjectStatusUpdater.SetParentObjStatus <TestAssemblyRepository, TestAssembly>(
TestAssemblyRepository.Instance, assemblyId, ObjectStatus.InQueue);
break;
case "testsuite":
var suite = TestSuiteRepository.Instance.Get(objId);
buildId = suite.BuildId;
ObjectStatusUpdater.SetParentObjStatus <TestAssemblyRepository, TestAssembly>(
TestAssemblyRepository.Instance, suite.ParentObjId.Value, ObjectStatus.InQueue);
break;
case "testassembly":
buildId = TestAssemblyRepository.Instance.Get(objId).BuildId;
break;
}
var buildRepo = BuildRepository.Instance;
var build = buildRepo.Get(buildId.Value);
build.Status = ObjectStatus.InQueue;
buildRepo.Update(build);
}
catch (Exception ex)
{
LogErrorMessage(ErrorMessage.ErorCode.RunOperationError, ex);
}
break;
case "stop":
var affectedScreenShots = new List <ScreenShot>();
try
{
affectedScreenShots = ObjectStatusUpdater.SetObjectsStatus(typeName, objId, ObjectStatus.Stopped);
}
catch (Exception ex)
{
LogErrorMessage(ErrorMessage.ErorCode.StopOperationError, ex);
}
var workers = ImageWorkerRepository.Instance.FindAll()
.Where(worker => worker.WorkerStatus == ImageWorker.StatusOfWorker.Available).ToList();
foreach (var imageWorker in workers)
{
var restImageProcessorClient = new RestImageProcessorClient(imageWorker.WorkerServiceUrl);
restImageProcessorClient.StopStopDiffGeneration(affectedScreenShots);
}
break;
default:
LogErrorMessage(ErrorMessage.ErorCode.RunOperationError,
$"OperationName {operationName} is not recognized. Possible values: run, stop");
return;
}
}
