public virtual void LogJobDefinitionOperation(string operation, string jobDefinitionId, string processDefinitionId, string processDefinitionKey, PropertyChange propertyChange)
{
if (UserOperationLogEnabled)
{
UserOperationLogContext context = new UserOperationLogContext();
UserOperationLogContextEntryBuilder entryBuilder = UserOperationLogContextEntryBuilder.Entry(operation, EntityTypes.JobDefinition).JobDefinitionId(jobDefinitionId).ProcessDefinitionId(processDefinitionId).ProcessDefinitionKey(processDefinitionKey).PropertyChanges(propertyChange);
if (jobDefinitionId != null)
{
JobDefinitionEntity jobDefinition = jobDefinitionManager.FindById(jobDefinitionId);
// Backward compatibility
if (jobDefinition != null)
{
entryBuilder.InContextOf(jobDefinition);
}
}
else if (processDefinitionId != null)
{
ProcessDefinitionEntity definition = processDefinitionManager.FindLatestProcessDefinitionById(processDefinitionId);
// Backward compatibility
if (definition != null)
{
entryBuilder.InContextOf(definition);
}
}
context.AddEntry(entryBuilder.Create());
FireUserOperationLog(context);
}
}
public virtual object Execute(CommandContext commandContext)
{
EnsureUtil.EnsureNotNull(typeof(NotValidException), "jobDefinitionId", JobDefinitionId);
JobDefinitionEntity jobDefinition = commandContext.JobDefinitionManager.FindById(JobDefinitionId);
EnsureUtil.EnsureNotNull(typeof(NotFoundException),
"Job definition with id '" + JobDefinitionId + "' does not exist", "jobDefinition", jobDefinition);
CheckUpdateProcess(commandContext, jobDefinition);
long?currentPriority = jobDefinition.OverridingJobPriority;
jobDefinition.JobPriority = Priority;
var opLogContext = new UserOperationLogContext();
CreateJobDefinitionOperationLogEntry(opLogContext, currentPriority, jobDefinition);
if (Cascade && Priority != null)
{
commandContext.JobManager.UpdateJobPriorityByDefinitionId(JobDefinitionId, Priority.Value);
CreateCascadeJobsOperationLogEntry(opLogContext, jobDefinition);
}
commandContext.OperationLogManager.LogUserOperations(opLogContext);
return(null);
}
public MigratingTimerJobInstance(JobEntity jobEntity, JobDefinitionEntity jobDefinitionEntity,
ScopeImpl targetScope, bool updateEvent, TimerDeclarationImpl targetTimerDeclaration)
: base(jobEntity, jobDefinitionEntity, targetScope)
{
TimerTriggerTargetScope = DetermineTimerTriggerTargetScope(jobEntity, targetScope);
this.UpdateEvent = updateEvent;
TargetJobDeclaration = targetTimerDeclaration;
}
protected internal virtual bool jobDefinitionsMatch(JobDefinitionEntity currentJobDefinition, JobDefinitionEntity newJobDefinition)
{
bool activitiesMatch = currentJobDefinition.ActivityId.Equals(newJobDefinition.ActivityId);
bool typesMatch = (string.ReferenceEquals(currentJobDefinition.JobType, null) && string.ReferenceEquals(newJobDefinition.JobType, null)) || (!string.ReferenceEquals(currentJobDefinition.JobType, null) && currentJobDefinition.JobType.Equals(newJobDefinition.JobType));
bool configurationsMatch = (string.ReferenceEquals(currentJobDefinition.JobConfiguration, null) && string.ReferenceEquals(newJobDefinition.JobConfiguration, null)) || (!string.ReferenceEquals(currentJobDefinition.JobConfiguration, null) && currentJobDefinition.JobConfiguration.Equals(newJobDefinition.JobConfiguration));
return(activitiesMatch && typesMatch && configurationsMatch);
}
// Job instance factory //////////////////////////////////////////
///
/// <returns> the created Job instances </returns>
public virtual T createJobInstance(S context)
{
T job = newJobInstance(context);
// set job definition id
string jobDefinitionId = resolveJobDefinitionId(context);
job.JobDefinitionId = jobDefinitionId;
if (!string.ReferenceEquals(jobDefinitionId, null))
{
JobDefinitionEntity jobDefinition = Context.CommandContext.JobDefinitionManager.findById(jobDefinitionId);
if (jobDefinition != null)
{
// if job definition is suspended while creating a job instance,
// suspend the job instance right away:
job.SuspensionState = jobDefinition.SuspensionState;
job.ProcessDefinitionKey = jobDefinition.ProcessDefinitionKey;
job.ProcessDefinitionId = jobDefinition.ProcessDefinitionId;
job.TenantId = jobDefinition.TenantId;
}
}
job.JobHandlerConfiguration = resolveJobHandlerConfiguration(context);
job.JobHandlerType = resolveJobHandlerType(context);
job.Exclusive = resolveExclusive(context);
job.Retries = resolveRetries(context);
job.Duedate = resolveDueDate(context);
// contentExecution can be null in case of a timer start event or
// and batch jobs unrelated to executions
ExecutionEntity contextExecution = resolveExecution(context);
if (Context.ProcessEngineConfiguration.ProducePrioritizedJobs)
{
long priority = Context.ProcessEngineConfiguration.JobPriorityProvider.determinePriority(contextExecution, this, jobDefinitionId);
job.Priority = priority;
}
if (contextExecution != null)
{
// in case of shared process definitions, the job definitions have no tenant id.
// To distinguish jobs between tenants and enable the tenant check for the job executor,
// use the tenant id from the execution.
job.TenantId = contextExecution.TenantId;
}
postInitialize(context, job);
return(job);
}
protected internal virtual void CreateJobDefinition(IProcessDefinition processDefinition, IJobDeclaration jobDeclaration)
{
IJobDefinitionManager jobDefinitionManager = JobDefinitionManager;
JobDefinitionEntity jobDefinitionEntity = JobDefinitionEntity.CreateJobDefinitionEntity(jobDeclaration);
jobDefinitionEntity.ProcessDefinitionId = processDefinition.Id;
jobDefinitionEntity.ProcessDefinitionKey = processDefinition.Key;
jobDefinitionEntity.TenantId = processDefinition.TenantId;
jobDefinitionManager.Add(jobDefinitionEntity);
jobDeclaration.JobDefinitionId = jobDefinitionEntity.Id;
}
public virtual JobDefinitionEntity createBatchJobDefinition()
{
batchJobDefinition = new JobDefinitionEntity(BatchJobHandler.JobDeclaration);
batchJobDefinition.JobConfiguration = id;
batchJobDefinition.TenantId = tenantId;
Context.CommandContext.JobDefinitionManager.insert(batchJobDefinition);
batchJobDefinitionId = batchJobDefinition.Id;
return(batchJobDefinition);
}
public virtual JobDefinitionEntity createMonitorJobDefinition()
{
monitorJobDefinition = new JobDefinitionEntity(BATCH_MONITOR_JOB_DECLARATION);
monitorJobDefinition.JobConfiguration = id;
monitorJobDefinition.TenantId = tenantId;
Context.CommandContext.JobDefinitionManager.insert(monitorJobDefinition);
monitorJobDefinitionId = monitorJobDefinition.Id;
return(monitorJobDefinition);
}
public virtual JobDefinitionEntity createSeedJobDefinition()
{
seedJobDefinition = new JobDefinitionEntity(BATCH_SEED_JOB_DECLARATION);
seedJobDefinition.JobConfiguration = id;
seedJobDefinition.TenantId = tenantId;
Context.CommandContext.JobDefinitionManager.insert(seedJobDefinition);
seedJobDefinitionId = seedJobDefinition.Id;
return(seedJobDefinition);
}
public virtual JobDefinitionEntity CreateMonitorJobDefinition()
{
monitorJobDefinition = new JobDefinitionEntity(BatchMonitorJobDeclaration);
monitorJobDefinition.JobConfiguration = Id;
monitorJobDefinition.TenantId = TenantId;
Context.CommandContext.JobDefinitionManager.Add(monitorJobDefinition);
MonitorJobDefinitionId = monitorJobDefinition.Id;
return(monitorJobDefinition);
}
public virtual JobDefinitionEntity CreateSeedJobDefinition()
{
seedJobDefinition = new JobDefinitionEntity(BatchSeedJobDeclaration);
seedJobDefinition.JobConfiguration = Id;
seedJobDefinition.TenantId = TenantId;
Context.CommandContext.JobDefinitionManager.Add(seedJobDefinition);
SeedJobDefinitionId = seedJobDefinition.Id;
return(seedJobDefinition);
}
protected internal virtual void CreateCascadeJobsOperationLogEntry(UserOperationLogContext opLogContext,
JobDefinitionEntity jobDefinition)
{
// old value is unknown
PropertyChange propertyChange = new PropertyChange(SetJobPriorityCmd.JobPriorityProperty, null,
jobDefinition.OverridingJobPriority);
UserOperationLogContextEntry entry =
UserOperationLogContextEntryBuilder.Entry(UserOperationLogEntryFields.OperationTypeSetPriority,
EntityTypes.Job).InContextOf(jobDefinition).PropertyChanges(propertyChange).Create();
opLogContext.AddEntry(entry);
}
// Job instance factory //////////////////////////////////////////
/// <returns> the created Job instances </returns>
public virtual T CreateJobInstance(object context)
{
var job = NewJobInstance(context);
// set job definition id
var jobDefinitionId = ResolveJobDefinitionId(context);
job.JobDefinitionId = jobDefinitionId;
if (!ReferenceEquals(jobDefinitionId, null))
{
JobDefinitionEntity jobDefinition = Context.CommandContext.JobDefinitionManager.FindById(jobDefinitionId);
if (jobDefinition != null)
{
// if job definition is suspended while creating a job instance,
// suspend the job instance right away:
job.SuspensionState = jobDefinition.SuspensionState;
job.ProcessDefinitionKey = jobDefinition.ProcessDefinitionKey;
job.ProcessDefinitionId = jobDefinition.ProcessDefinitionId;
job.TenantId = jobDefinition.TenantId;
}
}
job.JobHandlerConfiguration = ResolveJobHandlerConfiguration(context);
job.JobHandlerType = ResolveJobHandlerType(context);
job.Exclusive = ResolveExclusive(context);
job.Retries = ResolveRetries(context);
job.Duedate = ResolveDueDate(context);
// contentExecution can be null in case of a timer start event or
// and batch jobs unrelated to executions
var contextExecution = ResolveExecution(context);
if (Context.ProcessEngineConfiguration.ProducePrioritizedJobs)
{
//TODO this:AsyncBeforeMessageJobDeclaration类型转换异常
long priority = Context.ProcessEngineConfiguration.JobPriorityProvider.DeterminePriority(contextExecution, this, jobDefinitionId);
job.Priority = priority;
}
if (contextExecution != null)
{
job.TenantId = contextExecution.TenantId;
}
PostInitialize(context, job);
return(job);
}
public virtual UserOperationLogContextEntryBuilder inContextOf(JobDefinitionEntity jobDefinition)
{
entry_Renamed.JobDefinitionId = jobDefinition.Id;
entry_Renamed.ProcessDefinitionId = jobDefinition.ProcessDefinitionId;
entry_Renamed.ProcessDefinitionKey = jobDefinition.ProcessDefinitionKey;
if (!string.ReferenceEquals(jobDefinition.ProcessDefinitionId, null))
{
ProcessDefinitionEntity processDefinition = Context.ProcessEngineConfiguration.DeploymentCache.findDeployedProcessDefinitionById(jobDefinition.ProcessDefinitionId);
entry_Renamed.DeploymentId = processDefinition.DeploymentId;
}
return(this);
}
protected internal virtual void CheckUpdateProcess(CommandContext commandContext,
JobDefinitionEntity jobDefinition)
{
var processDefinitionId = jobDefinition.ProcessDefinitionId;
foreach (var checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.CheckUpdateProcessDefinitionById(processDefinitionId);
if (Cascade)
{
checker.CheckUpdateProcessInstanceByProcessDefinitionId(processDefinitionId);
}
}
}
protected internal override void CheckAuthorization(CommandContext commandContext)
{
foreach (var checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
if (!ReferenceEquals(JobDefinitionId, null))
{
IJobDefinitionManager jobDefinitionManager = commandContext.JobDefinitionManager;
JobDefinitionEntity jobDefinition = jobDefinitionManager.FindById(JobDefinitionId);
if (jobDefinition != null && !ReferenceEquals(jobDefinition.ProcessDefinitionKey, null))
{
var processDefinitionKey = jobDefinition.ProcessDefinitionKey;
checker.CheckUpdateProcessDefinitionByKey(processDefinitionKey);
if (includeSubResources)
{
checker.CheckUpdateProcessInstanceByProcessDefinitionKey(processDefinitionKey);
}
}
}
else
{
if (!ReferenceEquals(ProcessDefinitionId, null))
{
checker.CheckUpdateProcessDefinitionById(ProcessDefinitionId);
if (includeSubResources)
{
checker.CheckUpdateProcessInstanceByProcessDefinitionId(ProcessDefinitionId);
}
}
else
{
if (!ReferenceEquals(ProcessDefinitionKey, null))
{
checker.CheckUpdateProcessDefinitionByKey(ProcessDefinitionKey);
if (includeSubResources)
{
checker.CheckUpdateProcessInstanceByProcessDefinitionKey(ProcessDefinitionKey);
}
}
}
}
}
}
protected internal virtual bool JobDefinitionsMatch(JobDefinitionEntity currentJobDefinition,
JobDefinitionEntity newJobDefinition)
{
var activitiesMatch = currentJobDefinition.ActivityId.Equals(newJobDefinition.ActivityId);
var typesMatch = (ReferenceEquals(currentJobDefinition.JobType, null) &&
ReferenceEquals(newJobDefinition.JobType, null)) ||
(!ReferenceEquals(currentJobDefinition.JobType, null) &&
currentJobDefinition.JobType.Equals(newJobDefinition.JobType));
var configurationsMatch = (ReferenceEquals(currentJobDefinition.JobConfiguration, null) &&
ReferenceEquals(newJobDefinition.JobConfiguration, null)) ||
(!ReferenceEquals(currentJobDefinition.JobConfiguration, null) &&
currentJobDefinition.JobConfiguration.Equals(newJobDefinition.JobConfiguration));
return(activitiesMatch && typesMatch && configurationsMatch);
}
public virtual void handle(MigratingInstanceParseContext parseContext, MigratingActivityInstance activityInstance, IList <JobEntity> elements)
{
IDictionary <string, TimerDeclarationImpl> sourceTimerDeclarationsInEventScope = getTimerDeclarationsByTriggeringActivity(activityInstance.SourceScope);
IDictionary <string, TimerDeclarationImpl> targetTimerDeclarationsInEventScope = getTimerDeclarationsByTriggeringActivity(activityInstance.TargetScope);
foreach (JobEntity job in elements)
{
if (!isTimerJob(job))
{
// skip non timer jobs
continue;
}
MigrationInstruction migrationInstruction = parseContext.findSingleMigrationInstruction(job.ActivityId);
ActivityImpl targetActivity = parseContext.getTargetActivity(migrationInstruction);
if (targetActivity != null && activityInstance.migratesTo(targetActivity.EventScope))
{
// the timer job is migrated
JobDefinitionEntity targetJobDefinitionEntity = parseContext.getTargetJobDefinition(targetActivity.ActivityId, job.JobHandlerType);
TimerDeclarationImpl targetTimerDeclaration = targetTimerDeclarationsInEventScope.Remove(targetActivity.Id);
MigratingJobInstance migratingTimerJobInstance = new MigratingTimerJobInstance(job, targetJobDefinitionEntity, targetActivity, migrationInstruction.UpdateEventTrigger, targetTimerDeclaration);
activityInstance.addMigratingDependentInstance(migratingTimerJobInstance);
parseContext.submit(migratingTimerJobInstance);
}
else
{
// the timer job is removed
MigratingJobInstance removingJobInstance = new MigratingTimerJobInstance(job);
activityInstance.addRemovingDependentInstance(removingJobInstance);
parseContext.submit(removingJobInstance);
}
parseContext.consume(job);
}
if (activityInstance.migrates())
{
addEmergingTimerJobs(parseContext, activityInstance, sourceTimerDeclarationsInEventScope, targetTimerDeclarationsInEventScope);
}
}
public virtual void handle(MigratingInstanceParseContext parseContext, MigratingTransitionInstance transitionInstance, IList <JobEntity> elements)
{
foreach (JobEntity job in elements)
{
if (!isAsyncContinuation(job))
{
continue;
}
ScopeImpl targetScope = transitionInstance.TargetScope;
if (targetScope != null)
{
JobDefinitionEntity targetJobDefinitionEntity = parseContext.getTargetJobDefinition(transitionInstance.TargetScope.Id, job.JobHandlerType);
MigratingAsyncJobInstance migratingJobInstance = new MigratingAsyncJobInstance(job, targetJobDefinitionEntity, transitionInstance.TargetScope);
transitionInstance.DependentJobInstance = migratingJobInstance;
parseContext.submit(migratingJobInstance);
}
parseContext.consume(job);
}
}
protected internal static bool isAsyncJobDefinition(JobDefinitionEntity jobDefinition)
{
return(AsyncContinuationJobHandler.TYPE.Equals(jobDefinition.JobType));
}
protected internal override void CheckAuthorization(CommandContext commandContext)
{
foreach (ICommandChecker checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
if (!string.ReferenceEquals(JobId, null))
{
IJobManager jobManager = commandContext.JobManager;
JobEntity job = jobManager.FindJobById(JobId);
if (job != null)
{
string processInstanceId = job.ProcessInstanceId;
if (!string.ReferenceEquals(processInstanceId, null))
{
checker.CheckUpdateProcessInstanceById(processInstanceId);
}
else
{
// start timer job is not assigned to a specific process
// instance, that's why we have to check whether there
// exists a UPDATE_INSTANCES permission on process definition or
// a UPDATE permission on any process instance
string processDefinitionKey = job.ProcessDefinitionKey;
if (!string.ReferenceEquals(processDefinitionKey, null))
{
checker.CheckUpdateProcessInstanceByProcessDefinitionKey(processDefinitionKey);
}
}
// if (processInstanceId == null && processDefinitionKey == null):
// job is not assigned to any process instance nor process definition
// then it is always possible to activate/suspend the corresponding job
// -> no authorization check necessary
}
}
else
{
if (!string.IsNullOrEmpty(JobDefinitionId))
{
JobDefinitionEntity jobDefinition = commandContext.JobDefinitionManager.FindById(JobDefinitionId);
if (jobDefinition != null)
{
string processDefinitionKey = jobDefinition.ProcessDefinitionKey;
checker.CheckUpdateProcessInstanceByProcessDefinitionKey(processDefinitionKey);
}
}
else
{
if (!string.ReferenceEquals(ProcessInstanceId, null))
{
checker.CheckUpdateProcessInstanceById(ProcessInstanceId);
}
else
{
if (!string.ReferenceEquals(ProcessDefinitionId, null))
{
checker.CheckUpdateProcessInstanceByProcessDefinitionId(ProcessDefinitionId);
}
else
{
if (!string.ReferenceEquals(ProcessDefinitionKey, null))
{
checker.CheckUpdateProcessInstanceByProcessDefinitionKey(ProcessDefinitionKey);
}
}
}
}
}
}
}
public MigratingJobInstance(JobEntity jobEntity, JobDefinitionEntity jobDefinitionEntity, ScopeImpl targetScope)
{
this.jobEntity = jobEntity;
targetJobDefinitionEntity = jobDefinitionEntity;
this.targetScope = targetScope;
}
public MigratingAsyncJobInstance(JobEntity jobEntity, JobDefinitionEntity jobDefinitionEntity,
ScopeImpl targetScope) : base(jobEntity, jobDefinitionEntity, targetScope)
{
}
protected internal virtual void CreateJobDefinitionOperationLogEntry(UserOperationLogContext opLogContext,
long?previousPriority, JobDefinitionEntity jobDefinition)
{
PropertyChange propertyChange = new PropertyChange(JobDefinitionOverridingPriority, previousPriority,
jobDefinition.OverridingJobPriority);
UserOperationLogContextEntry entry =
UserOperationLogContextEntryBuilder.Entry(UserOperationLogEntryFields.OperationTypeSetPriority,
EntityTypes.JobDefinition).InContextOf(jobDefinition).PropertyChanges(propertyChange).Create();
opLogContext.AddEntry(entry);
}
