public async Task <CommandResult> Handle(RecalculateExecutionScheduleCommand request, CancellationToken cancellationToken)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
ExecutionSchedule schedule = await _entitiesRepository.GetFirstOrDefaultAsync <ExecutionSchedule>(st => st.Name == request.Name);
if (schedule == null)
{
throw new InvalidExecutionScheduleException("Execution Schedule with name " + request.Name + " is invalid.");
}
var executionScheduleLock = await _node.Handle(new RequestDataShard()
{
Type = schedule.ShardType,
ObjectId = schedule.Id,
CreateLock = true,
LockTimeoutMs = 10000
});
ExecutionSchedule existingValue;
if (executionScheduleLock.IsSuccessful && executionScheduleLock.AppliedLocked)
{
existingValue = (ExecutionSchedule)executionScheduleLock.Data;
existingValue.UpdateJournal(new Domain.Entities.JournalEntries.JournalEntry()
{
CreatedOn = DateTime.UtcNow,
Updates = new List <Domain.ValueObjects.Update>()
{
new Update()
{
Type = UpdateType.Override,
FieldName = "nextrun",
Value = SchedulerUtility.NextOccurence(existingValue.Schedule, DateTime.UtcNow)
}
}
});
var result = await _node.Handle(new AddShardWriteOperation()
{
Operation = ConsensusCore.Domain.Enums.ShardOperationOptions.Update,
WaitForSafeWrite = true,
Data = existingValue,
RemoveLock = true
});
}
stopwatch.Stop();
return(new CommandResult <ExecutionSchedule>()
{
ObjectRefId = schedule.Id.ToString(),
ElapsedMs = stopwatch.ElapsedMilliseconds,
Type = CommandResultTypes.Update,
Result = schedule
});
}
public async Task <CommandResult> Handle(UpdateExecutionScheduleCommand request, CancellationToken cancellationToken)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
ExecutionSchedule schedule = await _entitiesRepository.GetFirstOrDefaultAsync <ExecutionSchedule>(st => st.Name == request.Name);
if (schedule == null)
{
throw new InvalidExecutionScheduleException("Execution Schedule with name " + request.Name + " is invalid.");
}
if (request.Schedule != null)
{
foreach (var scheduleString in request.Schedule)
{
var isValid = SchedulerUtility.IsValidScheduleString(scheduleString);
if (!isValid)
{
throw new InvalidExecutionScheduleException("Schedule " + scheduleString + " is invalid.");
}
}
}
var executionScheduleLock = await _node.Handle(new RequestDataShard()
{
Type = schedule.ShardType,
ObjectId = schedule.Id,
CreateLock = true
});
ExecutionSchedule existingValue;
List <Update> updates = new List <Update>();
if (request.IsDisabled != null && schedule.IsDisabled != request.IsDisabled)
{
updates.Add(new Update()
{
Type = UpdateType.Override,
FieldName = "isdisabled",
Value = request.IsDisabled
});
}
if (request.Schedule != null && schedule.Schedule != request.Schedule)
{
updates.Add(new Update()
{
Type = UpdateType.Override,
FieldName = "nextrun",
Value = SchedulerUtility.NextOccurence(request.Schedule, DateTime.UtcNow)
});
updates.Add(new Update()
{
Type = UpdateType.Override,
FieldName = "schedule",
Value = request.Schedule
});
}
if (request.Description != null && schedule.Description != request.Description)
{
updates.Add(new Update()
{
Type = UpdateType.Override,
FieldName = "description",
Value = request.Description
});
}
if (executionScheduleLock.IsSuccessful && executionScheduleLock.AppliedLocked && updates.Count > 0)
{
existingValue = (ExecutionSchedule)executionScheduleLock.Data;
existingValue.UpdateJournal(new Domain.Entities.JournalEntries.JournalEntry()
{
CreatedOn = DateTime.UtcNow,
Updates = updates
});
var result = await _node.Handle(new AddShardWriteOperation()
{
Operation = ConsensusCore.Domain.Enums.ShardOperationOptions.Update,
WaitForSafeWrite = true,
Data = existingValue,
RemoveLock = true
});
}
stopwatch.Stop();
return(new CommandResult <ExecutionSchedule>()
{
ObjectRefId = schedule.Id.ToString(),
ElapsedMs = stopwatch.ElapsedMilliseconds,
Type = CommandResultTypes.Update,
Result = schedule
});
}
public async Task <CommandResult> Handle(CreateExecutionScheduleCommand request, CancellationToken cancellationToken)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
ExecutionSchedule schedule = await _entitiesRepository.GetFirstOrDefaultAsync <ExecutionSchedule>(st => st.Name == request.Name);
if (schedule != null)
{
throw new InvalidExecutionScheduleException("Execution Schedule with name " + request.Name + " is invalid.");
}
ExecutionTemplate template = await _entitiesRepository.GetFirstOrDefaultAsync <ExecutionTemplate>(st => st.Name == request.ExecutionTemplateName);
if (template == null)
{
throw new InvalidExecutionScheduleException("Execution Template with name " + request.ExecutionTemplateName + " is invalid.");
}
foreach (var scheduleString in request.Schedule)
{
var isValid = SchedulerUtility.IsValidScheduleString(scheduleString);
if (!isValid)
{
throw new InvalidExecutionScheduleException("Schedule " + scheduleString + " is invalid.");
}
}
var executionSchedule = new ExecutionSchedule(
Guid.NewGuid(),
request.Name,
request.ExecutionTemplateName,
request.Description,
request.CreatedBy,
request.Schedule,
SchedulerUtility.NextOccurence(request.Schedule)
);
var executionScheduleResponse = await _node.Handle(new AddShardWriteOperation()
{
Data = executionSchedule,
WaitForSafeWrite = true,
Operation = ConsensusCore.Domain.Enums.ShardOperationOptions.Create
});
if (request.RunImmediately)
{
await _mediator.Send(new ExecuteExecutionTemplateCommand()
{
CreatedBy = request.CreatedBy,
ExecutionScheduleId = executionSchedule.Id,
Name = executionSchedule.ExecutionTemplateName
});
}
stopwatch.Stop();
return(new CommandResult <ExecutionSchedule>()
{
ObjectRefId = executionSchedule.Id.ToString(),
ElapsedMs = stopwatch.ElapsedMilliseconds,
Type = CommandResultTypes.Create,
Result = executionSchedule
});
}
