public RunInstanceTests()
{
_runInstance = new RunInstance(
Guid.NewGuid(),
Guid.NewGuid(),
_repositoryFactoryMock.Object,
_auditEventRepositoryMock.Object,
_inputHandlerMock.Object,
_outputHandlerMock.Object,
null,
null,
_synchronizationServiceMock.Object,
_pipelineAuditEventRepositoryMock.Object,
_brsIndicatorManagerMock.Object,
_landmarkRunServiceMock.Object,
null,
null
);
}
private async Task <RunInstance> SaveInputsAsync(InputsViewModel inputs)
{
var runInstance = new RunInstance()
{
Setup = inputs.Setup.ToModel()
};
foreach (var region in inputs.Regions.Where(r => r.Selected == true))
{
runInstance.RunInstance_Region.Add(
new RunInstance_Region()
{
region_code = region.Entity.region_code
});
}
foreach (var region in inputs.Products.Where(p => p.Selected == true))
{
runInstance.RunInstance_Product.Add(
new RunInstance_Product()
{
product_code = region.Entity.product_code
});
}
foreach (var channel in inputs.Chanlels.Where(c => c.Selected == true))
{
runInstance.RunInstance_Channel.Add(
new RunInstance_Channel()
{
channel_code = channel.Entity.channel_code
});
}
var dataRepository = DataRepositoryTool.GetDataRepository();
await dataRepository.AddAsync(runInstance);
return(runInstance);
}
public void Execute(
Run run,
RunScenario scenario,
IReadOnlyCollection <AutoBookInstanceConfiguration> autoBookInstanceConfigurationsForRun,
double autoBookRequiredStorageGB,
ConcurrentBag <RunInstance> runInstances,
ConcurrentDictionary <Guid, ScenarioStatuses> newScenarioStatuses,
ConcurrentDictionary <Guid, bool> scenarioSyncStatuses,
bool autoDistributed)
{
AutoBookDomainObject autoBook = null;
IAutoBook autoBookInterface = null;
bool runStarted = false;
RaiseInfo($"Begin Execute for ScenarioID: { scenario.Id}");
try
{
AutoBookInstanceConfiguration runAutoBookInstanceConfiguration = null;
if (autoDistributed)
{
RaiseInfo($"AutoDistributed - RunScenarioTask Execute Starting ScenarioID ={ scenario.Id}, RunID ={ run.Id}");
//create instance for scenario
RunInstance runInstance = _runInstanceCreator.Create(run.Id, scenario.Id);
RaiseInfo($"AutoDistributed - about to enter: {nameof(runInstance.UploadInputFilesAndCreateAutoBookRequest)}");
runInstance.UploadInputFilesAndCreateAutoBookRequest(autoBookInstanceConfigurationsForRun, autoBookRequiredStorageGB);
RaiseInfo($"AutoDistributed - returned from: {nameof(runInstance.UploadInputFilesAndCreateAutoBookRequest)}");
// Flag run as started
runStarted = true;
runInstances.Add(runInstance);
_ = newScenarioStatuses.TryRemove(scenario.Id, out _); // Don't update scenario status at the end
scenarioSyncStatuses[scenario.Id] = false;
RaiseInfo($"AutoDistributed - RunScenarioTask Execute Started ScenarioID ={ scenario.Id}, RunID ={ run.Id}");
}
else
{
try
{
using (MachineLock.Create("xggameplan.AWSAutoBooks.GetFreeAutoBook",
new TimeSpan(0, 10, 0)))
{
foreach (var autoBookInstanceConfiguration in autoBookInstanceConfigurationsForRun)
{
autoBook = _autoBooks.GetFirstAdequateIdleAutoBook(autoBookInstanceConfiguration, autoBookRequiredStorageGB, true);
if (autoBook != null) // Got free AutoBook
{
RaiseInfo($"Got Free AutoBook: {autoBook.Id} ConfigurationId: {autoBook.InstanceConfigurationId}");
runAutoBookInstanceConfiguration = autoBookInstanceConfiguration;
break;
}
}
}
}
catch (MachineLockTimeoutException)
{
RaiseInfo($"MachineLockTimeoutException in xggameplan.AWSAutoBooks.GetFreeAutoBook");
}
// Get autobook interface
autoBookInterface = (autoBook == null) ? null : _autoBooks.GetInterface(autoBook);
// Get free AutoBook instance, will be locked so that it can't be used elsewhere
if (autoBook != null) // Free AutoBook - start run
{
RaiseInfo($"Free Autobook - Starting ScenarioID ={ scenario.Id}, AutoBookID ={autoBook?.Id}, RunID ={ run.Id}, Instance Configuration = { runAutoBookInstanceConfiguration.Description }");
// Start run, exception will cause cleanup below
RunInstance runInstance = _runInstanceCreator.Create(run.Id, scenario.Id);
runInstance.UploadInputFilesStartAutoBookRun(autoBookInterface, autoBook);
// Flag run as started
runStarted = true;
runInstances.Add(runInstance);
_ = newScenarioStatuses.TryRemove(scenario.Id, out _); // Don't update scenario status at the end
scenarioSyncStatuses[scenario.Id] = false;
RaiseInfo($"Started ScenarioID ={ scenario.Id}, AutoBookID ={ autoBook?.Id}, RunID ={ run.Id}, Instance Configuration = { runAutoBookInstanceConfiguration?.Description }");
}
else // No free AutoBook, awaiting for provisioning
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForWarningMessage(0, 0,
$"No free AutoBook, awaiting for provisioning, waiting for existing AutoBooks to be Idle (RunID={run.Id}, ScenarioID={scenario.Id})"));
// Update scenario so that it can be retried later when an AutoBook becomes idle
RunManager.UpdateScenarioStatuses(_repositoryFactory, _auditEventRepository, run.Id, new List <Guid> {
scenario.Id
},
new List <ScenarioStatuses> {
ScenarioStatuses.Scheduled
}, new List <DateTime?> {
null
});
_ = newScenarioStatuses.TryRemove(scenario.Id, out _); // Don't update scenario status at the end
scenarioSyncStatuses[scenario.Id] = false;
}
}
}
catch (System.Exception exception)
{
// Log exception but don't throw it. We want to try and start other scenarios
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, $"Error starting scenario (RunID={run.Id}, ScenarioID={scenario.Id}, AutoBookID={(autoBook == null ? "Unknown" : autoBook.Id)})", exception));
}
finally
{
// If we locked a free AutoBook instance but didn't start the scenario then reset to free, unlocks it.
if (!runStarted && autoBook != null)
{
autoBookInterface.ResetFree();
}
}
}
private async Task SaveInputRegions(int runInstanceId, IDataRepository dataRepository, RunInstance runInstance)
{
var selectedProductsCode = runInstance.RunInstance_Region.Select(r => r.region_code);
var allRegions = await dataRepository.GetListAsync <Region>();
var regions = from r in allRegions
select new { prodcut = r.region_name, r.region_code, flag_geography = selectedProductsCode.Contains(r.region_code) ? 1 : 0 };
_entitiesStorage.SaveContent(regions, runInstanceId, InputFileType.geography);
}
private async Task SaveInputChannels(int runInstanceId, IDataRepository dataRepository, RunInstance runInstance)
{
var selectedProductsCode = runInstance.RunInstance_Channel.Select(c => c.channel_code);
var allChannels = await dataRepository.GetListAsync <Channel>();
var channels = from c in allChannels
select new { prodcut = c.channel_name, c.channel_code, flag_channel = selectedProductsCode.Contains(c.channel_code) ? 1 : 0 };
_entitiesStorage.SaveContent(channels, runInstanceId, InputFileType.channel);
}
private async Task SaveInputProducts(int runInstanceId, IDataRepository dataRepository, RunInstance runInstance)
{
var selectedProductsCode = runInstance.RunInstance_Product.Select(p => p.product_code);
var allProducts = await dataRepository.GetListAsync <Product>();
var products = from p in allProducts
select new { prodcut = p.product_name, p.product_code, flag_product = selectedProductsCode.Contains(p.product_code) ? 1 : 0 };
_entitiesStorage.SaveContent(products, runInstanceId, InputFileType.product);
}
public TaskResult Execute(TaskInstance taskInstance)
{
var taskResult = new TaskResult();
Guid runId = Guid.Empty;
Guid scenarioId = Guid.Empty;
string autoBookId = String.Empty;
try
{
StartActiveNotifier(taskInstance.Id);
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.InProgress, null);
// Read parameters
runId = new Guid(taskInstance.Parameters["RunId"]);
scenarioId = new Guid(taskInstance.Parameters["ScenarioId"]);
autoBookId = taskInstance.Parameters["AutoBookId"];
AutoBookStatuses autoBookStatus = (AutoBookStatuses)Enum.Parse(typeof(AutoBookStatuses), taskInstance.Parameters["AutoBookStatus"], true);
using var scope = _repositoryFactory.BeginRepositoryScope();
// Get AutoBook instance
var autoBookRepository = scope.CreateRepository <IAutoBookRepository>();
var autoBook = autoBookRepository.Get(autoBookId);
RunInstance runInstance = _runInstanceCreator.Create(runId, scenarioId);
// Check AutoBook status
switch (autoBookStatus)
{
case AutoBookStatuses.Task_Completed:
runInstance.HandleCompletedSuccess();
break;
case AutoBookStatuses.Task_Error:
runInstance.HandleCompletedTaskError();
break;
case AutoBookStatuses.Fatal_Error:
runInstance.HandleCompletedFatalError(autoBook);
break;
}
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory,
TaskInstanceStatues.CompletedSuccess, DateTime.UtcNow);
taskResult.Status = TaskInstanceStatues.CompletedSuccess;
}
catch (Exception exception)
{
_auditEventRepository.Insert(AuditEventFactory.CreateAuditEventForException(0, 0, string.Format("Error executing task for scenario completed (TaskInstanceID={0}, RunID={1}, ScenarioID={2}, AutoBookID={3})", taskInstance.Id, runId, scenarioId, autoBookId), exception));
TaskUtilities.UpdateTaskInstanceStatus(taskInstance.Id, _repositoryFactory, TaskInstanceStatues.CompletedError, DateTime.UtcNow);
taskResult.Status = TaskInstanceStatues.CompletedError;
taskResult.Exception = exception;
}
finally
{
StopActiveNotifier();
}
return(taskResult);
}
