private IReadWritableGroupEntity CreateGroupEntity(int key, List <JobCriteria> criteria, bool isManual,
string triggeredBy, List <int> processKeys)
{
var serializer = _serializersFactory.GetSerializer <JobCriteria>();
var crit = serializer.SerializeToString(criteria);
IReadWritableGroupEntity entity = _entityFactory.CreateGroupEntity();
//IGroupEntity entity = _entityFactory.CreateGroupEntity(key, crit, isManual, false, triggeredBy, TaskCompletionStatus.Pending.Name);
IWritableGroupEntity entityW = entity;
entityW.Criteria = crit;
entityW.GroupKey = key;
entityW.IsManual = isManual;
entityW.IsResubmission = false;
entityW.SubmittedBy = triggeredBy;
entityW.State = CompletionStatus.Pending.Name;
if (processKeys != null)
{
entityW.Payload = serializer.SerializeToString(processKeys);
}
//IGroupEntity g = entity;
var entity2 = _stateManager.CreateGroupEntity(entity);
return(entity2);
}
public JobScheduler(ISerializersFactory factory, IPubSubFactory pubSubFactory, IBatchLoggerFactory loggerFactory)
{
SystemLogger = loggerFactory.GetSystemLogger();
_publisher = pubSubFactory.GetPublisher(CancellationToken.None, SystemLogger, nameof(IWatchDogMessage));
//_ser = SerializersFactory.Instance.GetSerializer<List<JobCriteria>>();
//JsonSerializer serializer=new JsonSerializer();
_ser = factory.GetSerializer(typeof(JobCriteria));
}
public ISerializer GetSerializer(ITask taskHandler)
{
return(_taskSerializers.GetOrAdd(taskHandler.ProcessKey, key =>
{
var serializer = taskHandler.Serializer;
if (serializer == null)
{
Type[] interfaces = taskHandler.GetType().GetInterfaces().Where(intrface => intrface.IsGenericType)
.ToArray();
var serializerType = interfaces.First(x => x.GetGenericTypeDefinition() == typeof(ITask <,>))
.GetGenericArguments().First(a => !typeof(ITaskContext).IsAssignableFrom(a));
serializer = _serializersFactory.GetSerializer(serializerType);
}
return serializer ?? _serializersFactory.GetSerializer(typeof(object));
}));
}
internal SubmittedGroup CreateProcesses(IReadWritableGroupEntity @group, List <int> processIds,
List <JobCriteria> messageCriteria)
{
var groupLogger = _loggerFactory.GetGroupLogger(group.Id, group.GroupKey);
groupLogger.Trace("Starting group");
if (processIds == null || processIds.Count == 0)
{
_logger.Error("No process found for group");
StopGroup(@group, "No process found for group");
return(null);
}
var serializer = _serializersFactory.GetSerializer <JobCriteria>();
GroupStartContext context = new GroupStartContext(group, groupLogger, messageCriteria, Bus);
var groupSubscribers = _batchEngineSubscribers.GetGroupSubscribers().ToList();
foreach (var groupSubscriber in groupSubscribers)
{
if (groupSubscriber.GroupKey != group.GroupKey)
{
continue;
}
context.CurrentSubscriber = groupSubscriber;
Robustness.Instance.SafeCall(() => { groupSubscriber.OnGroupStarting(context); }, groupLogger);
context.CurrentSubscriber = null;
}
if (context.StopFlag)
{
groupLogger.Info("Group stopped by subscriber");
StopGroup(group, "Group stopped by subscriber");
return(null);
}
//todo get group processes and add to queue
List <(JobCriteria Criteria, IReadWritableProcessState ProcessState)> process2Submit = new List <(JobCriteria Criteria, IReadWritableProcessState ProcessState)>(); // List<IReadWritableProcessState>();
List <IReadWritableProcessState> processList = new List <IReadWritableProcessState>();
foreach (var processId in processIds)
{
var process = _entityFactory.CreateProcessEntity();
process.ProcessId = processId;
//process
//IReadWritableProcessState process = erf wer GetKeyProcesses(processKey);
//IWritableProcessState writableProcess = process;
process.GroupId = group.Id;
//process.CorrelationId=Guid.NewGuid();
processList.Add(process);
}
if (processList.Count == 0)
{
_logger.Error("No process found for group");
StopGroup(group, "No process found for group");
return(null);
}
//if (messageCriteria.Count == 1)
//{
// var cta = messageCriteria[0];
// process2submit.AddRange(processList.Select(s =>
// {
// ((IWritableProcessState)s).Criteria = serializer.SerializeToString(cta);
// return s;
// }));
//}
//else
{
int groupSeqId = 0;
foreach (var criteria in messageCriteria)
{
groupSeqId++;
foreach (var process in processList)
{
var p = process.Clone(_entityFactory);
p.Criteria = serializer.SerializeToString(criteria);
p.CorrelationId = Guid.NewGuid();
process.CompanyId = criteria.CompanyId;
process.BranchId = criteria.BranchId;
process.SubTenantId = criteria.SubTenantId;
p.ProcessingDate = criteria.ProcessingDate;
p.Status = CompletionStatus.Pending;
p.Result = ResultStatus.Empty;
p.GroupSeqId = groupSeqId;
//p.Tag = criteria.Tag; //todo
process2Submit.Add((criteria, p));
}
}
}
_logger.Trace($"Submitting processes {process2Submit.Count}");
SubmitProcesses(process2Submit, group);
_logger.Trace($"Submission complete of {process2Submit.Count} processes");
foreach (var groupSubscriber in groupSubscribers)
{
if (groupSubscriber.GroupKey != group.GroupKey)
{
continue;
}
context.CurrentSubscriber = groupSubscriber;
Robustness.Instance.SafeCall(() => { groupSubscriber.OnGroupSubmitted(context); }, groupLogger);
context.CurrentSubscriber = null;
}
if (context.StopFlag)
{
groupLogger.Info("Group stopped by subscriber");
StopGroup(group, "Group stopped by subscriber");
return(null);
}
//var nextProcesses = GetNextProcesses(null);
//nextProcesses.ForEach(p =>
//{
// var volumeMessage = new ProcessExecutionContext(BatchLoggerFactory.GetProcessLogger(p.Id, p.ProcessKey), p);
// Bus.Instance.HandleVolumeRequest(volumeMessage);
//});
SubmittedGroup gGroup = new SubmittedGroup(group, process2Submit.Select(s => s.ProcessState).ToList());
return(gGroup);
}
public void Handle <T>(IEnumerable <T> volume, IProcessExecutionContextWithVolume processContext, CancellationToken token)
{
if (volume == null)
{
processContext.Logger.Info("No volume returned");
return;
}
bool hasVolume = false;
var serializer = _serializersFactory.GetSerializer <T>();
int currentCount = 0;
int batchSize = 100;
try
{
Bus.HandleDbCommand(new DbAction(DbActions.Transaction, () => //create transaction in Db Bus pipeline
{
var volumeDeletedCount = ExecuteNonQuery(Constant.SQLDeleteProcessVolume, processContext.ProcessState.Id);
if (volumeDeletedCount > 0)
{
processContext.Logger.Warn($"Existing volume {volumeDeletedCount} deleting");
}
}));
//using (var unitOfWork = ) //IsolationLevel.Snapshot //todo check isolation level with db team, is it enabled by default
{
foreach (var v in volume)
{
var payLoad = serializer.SerializeToString(v);
IReadWritableTaskState state = CreateNew();
state.Payload = payLoad;
state.ProcessId = processContext.ProcessState.Id;
state.CurrentState = ResultStatus.Empty.Name;
currentCount++;
if (currentCount >= batchSize)
{
token.ThrowIfCancellationRequested();
hasVolume = true;
//Persist();
currentCount = 0;
//Clear();//remove persisted items
}
}
//if (Entity.Count>0)
{
token.ThrowIfCancellationRequested();
hasVolume = true;
// Persist();
}
//Commit();
}
}
finally
{
//dispose / rollback
}
if (hasVolume)
{
processContext.SetVolumeGenerated();
}
}
