protected virtual AcquiredJobs AcquireJobs(JobAcquisitionContext context, IJobAcquisitionStrategy acquisitionStrategy, ProcessEngineImpl currentProcessEngine) { ICommandExecutor commandExecutor = ((ProcessEngineConfigurationImpl)currentProcessEngine.ProcessEngineConfiguration).CommandExecutorTxRequired; var 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 ProcessEngineImpl(ProcessEngineConfigurationImpl processEngineConfiguration) { this.processEngineConfiguration = processEngineConfiguration; Name = processEngineConfiguration.ProcessEngineName; RepositoryService = processEngineConfiguration.RepositoryService; RuntimeService = processEngineConfiguration.RuntimeService; HistoryService = processEngineConfiguration.HistoryService; IdentityService = processEngineConfiguration.IdentityService; TaskService = processEngineConfiguration.TaskService; FormService = processEngineConfiguration.FormService; ManagementService = processEngineConfiguration.ManagementService; AuthorizationService = processEngineConfiguration.AuthorizationService; //this.caseService = processEngineConfiguration.CaseService; FilterService = processEngineConfiguration.FilterService; ExternalTaskService = processEngineConfiguration.ExternalTaskService; DecisionService = processEngineConfiguration.DecisionService; DatabaseSchemaUpdate = processEngineConfiguration.DatabaseSchemaUpdate; JobExecutor = processEngineConfiguration.JobExecutor; commandExecutor = processEngineConfiguration.CommandExecutorTxRequired; CommandExecutorSchemaOperations = processEngineConfiguration.CommandExecutorSchemaOperations; //SessionFactories = processEngineConfiguration.SessionFactories; HistoryLevel = processEngineConfiguration.HistoryLevel; TransactionContextFactory = processEngineConfiguration.TransactionContextFactory; Log.LogDebug("使用的TransactionContextFactory:", TransactionContextFactory.GetType().Name.ToString()); //TODO 数据库初始化入口 //ExecuteSchemaOperations(); if (ReferenceEquals(Name, null)) { Name = ProcessEngines.NameDefault; Log.ProcessEngineCreated(ProcessEngines.NameDefault); } else { Log.ProcessEngineCreated(Name); } ProcessEngines.RegisterProcessEngine(this); if (JobExecutor != null) { JobExecutor.RegisterProcessEngine(this); } if (processEngineConfiguration.MetricsEnabled) { var reporterId = processEngineConfiguration.MetricsReporterIdProvider.ProvideId(this); var dbMetricsReporter = processEngineConfiguration.DbMetricsReporter; dbMetricsReporter.ReporterId = reporterId; if (processEngineConfiguration.DbMetricsReporterActivate) { dbMetricsReporter.Start(); } } }
public override void Run() { lock (this) { Log.StartingToAcquireJobs(JobExecutor.Name); var acquisitionStrategy = InitializeAcquisitionStrategy(); while (!IsInterrupted) { AcquisitionContext.Reset(); AcquisitionContext.AcquisitionTime = (DateTime.Now.Ticks / 10000000);//DateTime.Now.Millisecond; var engineIterator = JobExecutor.EngineIterator(); try { while (engineIterator.MoveNext()) { var currentProcessEngine = engineIterator.Current; if (!JobExecutor.HasRegisteredEngine(currentProcessEngine)) { continue; } var acquiredJobs = AcquireJobs(AcquisitionContext, acquisitionStrategy, currentProcessEngine); ExecuteJobs(AcquisitionContext, currentProcessEngine, acquiredJobs); } } catch (System.Exception e) { Log.ExceptionDuringJobAcquisition(e); AcquisitionContext.AcquisitionException = e; } AcquisitionContext.JobAdded = IsJobAdded; ConfigureNextAcquisitionCycle(AcquisitionContext, acquisitionStrategy); //The clear had to be done after the configuration, since a hint can be //appear in the suspend and the flag shouldn't be cleaned in this case. //The loop will restart after suspend with the isJobAdded flag and //reconfigure with this flag ClearJobAddedNotification(); var waitTime = acquisitionStrategy.WaitTime; // wait the requested wait time minus the time that acquisition itself took // this makes the intervals of job acquisition more constant and therefore predictable waitTime = Math.Max(0, (AcquisitionContext.AcquisitionTime + waitTime) - (DateTime.Now.Ticks / 10000000)); SuspendAcquisition(waitTime); } Log.StoppedJobAcquisition(JobExecutor.Name); } }
public BackoffJobAcquisitionStrategy(JobExecutor jobExecutor) : this(jobExecutor.WaitTimeInMillis, jobExecutor.WaitIncreaseFactor, jobExecutor.MaxWait, jobExecutor.BackoffTimeInMillis, jobExecutor.WaitIncreaseFactor, jobExecutor.MaxBackoff, jobExecutor.BackoffDecreaseThreshold, jobExecutor.MaxJobsPerAcquisition) { }
public virtual void run() { try { ESS.FW.Bpm.Engine.Impl.JobExecutor.JobExecutor jobExecutor = outerInstance.processEngineConfiguration.JobExecutor; jobs = outerInstance.processEngineConfiguration.CommandExecutorTxRequired.Execute(new ControlledCommand <AcquiredJobs>(activeThread, new AcquireJobsCmd(jobExecutor))); } catch (OptimisticLockingException e) { this.exception = e; } Debug.WriteLine(TestContext.CurrentContext.Test.Name + " ends"); }
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 var additionalJobs = context.AdditionalJobBatchesByEngine.GetValueOrNull(currentProcessEngine.Name); if (additionalJobs != null) { foreach (var jobBatch in additionalJobs) { Log.ExecuteJobs(currentProcessEngine.Name, jobBatch); JobExecutor.ExecuteJobs(jobBatch, currentProcessEngine); } } // submit those jobs that were acquired in the current cycle foreach (var jobIds in acquiredJobs.JobIdBatches) { Log.ExecuteJobs(currentProcessEngine.Name, jobIds); JobExecutor.ExecuteJobs(jobIds, currentProcessEngine); } }
////////// helper methods //////////////////////////// public virtual void WaitForJobExecutorToProcessAllJobs(long maxMillisToWait, int intervalMillis, ESS.FW.Bpm.Engine.Impl.JobExecutor.JobExecutor jobExecutor, IRuntimeService runtimeService, bool shutdown) { try { InteruptTask task = new InteruptTask(Thread.CurrentThread); System.Threading.Timer timer = new Timer(task.Run, null, maxMillisToWait, 0); bool areJobsAvailable = true; try { while (areJobsAvailable && !task.TimeLimitExceeded) { Thread.Sleep(intervalMillis); areJobsAvailable = AreJobsAvailable(runtimeService); } } catch (ThreadInterruptedException e) { } finally { timer.Change(-1, 0); } if (areJobsAvailable) { throw new ProcessEngineException("time limit of " + maxMillisToWait + " was exceeded"); } } finally { if (shutdown) { jobExecutor.Shutdown(); } } }
protected internal void setUp() { //base.SetUp(); jobExecutor = processEngineConfiguration.JobExecutor; }
public SequentialJobAcquisitionRunnable(JobExecutor jobExecutor) : base(jobExecutor) { AcquisitionContext = InitializeAcquisitionContext(); }
public ExecuteJobsRunnable(IList <string> jobIds, ProcessEngineImpl processEngine) { _jobIds = jobIds; _processEngine = processEngine; _jobExecutor = ((ProcessEngineConfigurationImpl)processEngine.ProcessEngineConfiguration).JobExecutor; }
private AcquiredJobs GetExecutableJobs(ESS.FW.Bpm.Engine.Impl.JobExecutor.JobExecutor jobExecutor) { return(processEngineConfiguration.CommandExecutorTxRequired.Execute(new AcquireJobsCmd(jobExecutor))); }
public virtual void JobsRejected(IList <string> jobIds, ProcessEngineImpl processEngine, JobExecutor jobExecutor) { var acquireJobsRunnable = jobExecutor.AcquireJobsRunnable; if (acquireJobsRunnable is SequentialJobAcquisitionRunnable) { var context = ((SequentialJobAcquisitionRunnable)acquireJobsRunnable).AcquisitionContext; context.SubmitRejectedBatch(processEngine.Name, jobIds); } else { jobExecutor.GetExecuteJobsRunnable(jobIds, processEngine).Run(null); } }
public AcquireJobsRunnable(JobExecutor jobExecutor) { this.JobExecutor = jobExecutor; }
public DefaultAcquireJobsCommandFactory(JobExecutor jobExecutor) { this.JobExecutor = jobExecutor; }
public virtual void JobsRejected(IList <string> jobIds, ProcessEngineImpl processEngine, JobExecutor jobExecutor) { jobExecutor.GetExecuteJobsRunnable(jobIds, processEngine).Run(null); }
public MessageAddedNotification(JobExecutor jobExecutor) { this.JobExecutor = jobExecutor; }