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); }