public virtual void reconfigure(JobAcquisitionContext context)
{
reconfigureIdleLevel(context);
reconfigureBackoffLevel(context);
reconfigureNumberOfJobsToAcquire(context);
executionSaturated = allSubmittedJobsRejected(context);
}
/// <returns> true, if all acquired jobs (spanning all engines) were rejected for execution </returns>
protected internal virtual bool allSubmittedJobsRejected(JobAcquisitionContext context)
{
foreach (KeyValuePair <string, AcquiredJobs> acquiredJobsForEngine in context.AcquiredJobsByEngine.SetOfKeyValuePairs())
{
string engineName = acquiredJobsForEngine.Key;
IList <IList <string> > acquiredJobBatches = acquiredJobsForEngine.Value.JobIdBatches;
IList <IList <string> > resubmittedJobBatches = context.AdditionalJobsByEngine[engineName];
IList <IList <string> > rejectedJobBatches = context.RejectedJobsByEngine[engineName];
int numJobsSubmittedForExecution = acquiredJobBatches.Count;
if (resubmittedJobBatches != null)
{
numJobsSubmittedForExecution += resubmittedJobBatches.Count;
}
int numJobsRejected = 0;
if (rejectedJobBatches != null)
{
numJobsRejected += rejectedJobBatches.Count;
}
// if not all jobs scheduled for execution have been rejected
if (numJobsRejected == 0 || numJobsSubmittedForExecution > numJobsRejected)
{
return(false);
}
}
return(true);
}
protected internal virtual AcquiredJobs acquireJobs(JobAcquisitionContext context, JobAcquisitionStrategy acquisitionStrategy, ProcessEngineImpl currentProcessEngine)
{
CommandExecutor commandExecutor = currentProcessEngine.ProcessEngineConfiguration.CommandExecutorTxRequired;
int numJobsToAcquire = acquisitionStrategy.getNumJobsToAcquire(currentProcessEngine.Name);
AcquiredJobs acquiredJobs = null;
if (numJobsToAcquire > 0)
{
jobExecutor.logAcquisitionAttempt(currentProcessEngine);
acquiredJobs = commandExecutor.execute(jobExecutor.getAcquireJobsCmd(numJobsToAcquire));
}
else
{
acquiredJobs = new AcquiredJobs(numJobsToAcquire);
}
context.submitAcquiredJobs(currentProcessEngine.Name, acquiredJobs);
jobExecutor.logAcquiredJobs(currentProcessEngine, acquiredJobs.size());
jobExecutor.logAcquisitionFailureJobs(currentProcessEngine, acquiredJobs.NumberOfJobsFailedToLock);
LOG.acquiredJobs(currentProcessEngine.Name, acquiredJobs);
return(acquiredJobs);
}
public virtual void jobsRejected(IList <string> jobIds, ProcessEngineImpl processEngine, JobExecutor jobExecutor)
{
AcquireJobsRunnable acquireJobsRunnable = jobExecutor.AcquireJobsRunnable;
if (acquireJobsRunnable is SequentialJobAcquisitionRunnable)
{
JobAcquisitionContext context = ((SequentialJobAcquisitionRunnable)acquireJobsRunnable).AcquisitionContext;
context.submitRejectedBatch(processEngine.Name, jobIds);
}
else
{
jobExecutor.getExecuteJobsRunnable(jobIds, processEngine).run();
}
}
protected internal virtual void reconfigureNumberOfJobsToAcquire(JobAcquisitionContext context)
{
// calculate the number of jobs to acquire next time
jobsToAcquire.Clear();
foreach (KeyValuePair <string, AcquiredJobs> acquiredJobsEntry in context.AcquiredJobsByEngine.SetOfKeyValuePairs())
{
string engineName = acquiredJobsEntry.Key;
int numJobsToAcquire = (int)(baseNumJobsToAcquire * Math.Pow(backoffIncreaseFactor, backoffLevel));
IList <IList <string> > rejectedJobBatchesForEngine = context.RejectedJobsByEngine[engineName];
if (rejectedJobBatchesForEngine != null)
{
numJobsToAcquire -= rejectedJobBatchesForEngine.Count;
}
numJobsToAcquire = Math.Max(0, numJobsToAcquire);
jobsToAcquire[engineName] = numJobsToAcquire;
}
}
protected internal virtual void reconfigureIdleLevel(JobAcquisitionContext context)
{
if (context.JobAdded)
{
idleLevel = 0;
}
else
{
if (context.areAllEnginesIdle() || context.AcquisitionException != null)
{
if (idleLevel < maxIdleLevel)
{
idleLevel++;
}
}
else
{
idleLevel = 0;
}
}
}
protected internal virtual void executeJobs(JobAcquisitionContext context, ProcessEngineImpl currentProcessEngine, AcquiredJobs acquiredJobs)
{
// submit those jobs that were acquired in previous cycles but could not be scheduled for execution
IList <IList <string> > additionalJobs = context.AdditionalJobsByEngine[currentProcessEngine.Name];
if (additionalJobs != null)
{
foreach (IList <string> jobBatch in additionalJobs)
{
LOG.executeJobs(currentProcessEngine.Name, jobBatch);
jobExecutor.executeJobs(jobBatch, currentProcessEngine);
}
}
// submit those jobs that were acquired in the current cycle
foreach (IList <string> jobIds in acquiredJobs.JobIdBatches)
{
LOG.executeJobs(currentProcessEngine.Name, jobIds);
jobExecutor.executeJobs(jobIds, currentProcessEngine);
}
}
protected internal virtual void reconfigureBackoffLevel(JobAcquisitionContext context)
{
// if for any engine, jobs could not be locked due to optimistic locking, back off
if (context.hasJobAcquisitionLockFailureOccurred())
{
numAcquisitionsWithoutLockingFailure = 0;
applyJitter = true;
if (backoffLevel < maxBackoffLevel)
{
backoffLevel++;
}
}
else
{
applyJitter = false;
numAcquisitionsWithoutLockingFailure++;
if (numAcquisitionsWithoutLockingFailure >= backoffDecreaseThreshold && backoffLevel > 0)
{
backoffLevel--;
numAcquisitionsWithoutLockingFailure = 0;
}
}
}
public SequentialJobAcquisitionRunnable(JobExecutor jobExecutor) : base(jobExecutor)
{
acquisitionContext = initializeAcquisitionContext();
}
/// <summary>
/// Reconfigure the acquisition strategy based on the current cycle's acquisition context.
/// A strategy implementation may update internal data structure to calculate a different wait time
/// before the next cycle of acquisition is performed.
/// </summary>
protected internal virtual void configureNextAcquisitionCycle(JobAcquisitionContext acquisitionContext, JobAcquisitionStrategy acquisitionStrategy)
{
acquisitionStrategy.reconfigure(acquisitionContext);
}
