@Override public int compareTo( IdentifiableObject jobConfiguration ) { JobConfiguration compareJobConfiguration = (JobConfiguration) jobConfiguration; if ( jobType != compareJobConfiguration.getJobType() ) { return -1; } if ( jobStatus != compareJobConfiguration.getJobStatus() ) { return -1; } if ( jobParameters != compareJobConfiguration.getJobParameters() ) { return -1; } if ( continuousExecution != compareJobConfiguration.isContinuousExecution() ) { return -1; } if ( enabled != compareJobConfiguration.isEnabled() ) { return -1; } if ( !cronExpression.equals( compareJobConfiguration.getCronExpression() ) ) { return 1; } return -1; }
public JobConfigurationWebMessageResponse( JobConfiguration jobConfiguration ) { this.name = jobConfiguration.getDisplayName(); this.id = jobConfiguration.getUid(); this.created = jobConfiguration.getCreated(); this.jobType = jobConfiguration.getJobType(); this.jobStatus = jobConfiguration.getJobStatus(); this.jobParameters = jobConfiguration.getJobParameters(); this.relativeNotifierEndpoint = "/api/system/tasks/" + this.jobType + "/" + this.id; }
@Override public void preUpdate( IdentifiableObject object, IdentifiableObject persistedObject, ObjectBundle bundle ) { if ( !JobConfiguration.class.isInstance( object ) ) { return; } JobConfiguration newObject = (JobConfiguration) object; JobConfiguration persObject = (JobConfiguration) persistedObject; newObject.setLastExecuted( persObject.getLastExecuted() ); newObject.setLastExecutedStatus( persObject.getLastExecutedStatus() ); newObject.setLastRuntimeExecution( persObject.getLastRuntimeExecution() ); if ( setDefaultCronExpressionWhenDisablingContinuousExectution( newObject, persObject ) ) { newObject.setCronExpression( HOUR_CRON ); } schedulingManager.stopJob( (JobConfiguration) persistedObject ); }
private boolean setDefaultCronExpressionWhenDisablingContinuousExectution( JobConfiguration newObject, JobConfiguration persistedObject ) { return ( !newObject.isContinuousExecution() && persistedObject.isContinuousExecution() ) && newObject.getCronExpression().equals( CONTINOUS_CRON ); }
public boolean isJobConfigurationRunning( JobConfiguration jobConfiguration ) { if ( jobConfiguration.isInMemoryJob() ) { return false; } return !jobConfiguration.isContinuousExecution() && runningJobConfigurations.stream().anyMatch( jobConfig -> jobConfig.getJobType().equals( jobConfiguration.getJobType() ) && !jobConfig.isContinuousExecution() ); }
JobConfiguration persitedJobConfiguration = jobConfigurationService.getJobConfigurationByUid( jobConfiguration.getUid() ); if ( persitedJobConfiguration != null && !persitedJobConfiguration.isConfigurable() ) if ( !Objects.equals( persitedJobConfiguration.compareTo( jobConfiguration ), SUCCESS ) ) .add( new ErrorReport( JobConfiguration.class, ErrorCode.E7003, jobConfiguration.getJobType() ) ); persitedJobConfiguration.setCronExpression( jobConfiguration.getCronExpression() ); jobConfiguration = persitedJobConfiguration; if ( !jobConfiguration.isContinuousExecution() ) if ( Objects.isNull( jobConfiguration.getCronExpression() ) ) if ( !CronSequenceGenerator.isValidExpression( jobConfiguration.getCronExpression() ) ) jobConfiguration.getJobParameters() != null ? jobConfiguration.getJobParameters().validate() : null; if ( !Objects.isNull( parameterValidation ) ) Job job = schedulingManager.getJob( jobConfiguration.getJobType() ); ErrorReport jobValidation = job.validate(); if ( jobValidation != null )
if ( jobConfig.isEnabled() ) Date oldExecutionTime = jobConfig.getNextExecutionTime(); jobConfig.setNextExecutionTime( null ); jobConfig.setJobStatus( SCHEDULED ); jobConfigurationService.updateJobConfiguration( jobConfig ); if ( jobConfig.getLastExecutedStatus() == FAILED || (!jobConfig.isContinuousExecution() && oldExecutionTime != null && oldExecutionTime.compareTo( now ) < 0) ) unexecutedJobs.add( "\nJob [" + jobConfig.getUid() + ", " + jobConfig.getName() + "] has status failed or was scheduled in server downtime. Actual execution time was supposed to be: " + oldExecutionTime );
if ( !jobConfiguration.isEnabled() ) if ( jobConfiguration.isLeaderOnlyJob() && !leaderManager.isLeader() ) String.format( NOT_LEADER_SKIP_LOG, jobConfiguration.getJobType(), jobConfiguration.getName() ) ); return; if ( jobConfiguration.isInMemoryJob() ) jobConfiguration.setJobStatus( JobStatus.RUNNING ); schedulingManager.jobConfigurationStarted( jobConfiguration ); jobConfiguration.setNextExecutionTime( null ); jobConfiguration.setLastExecutedStatus( JobStatus.COMPLETED ); "Job '" + jobConfiguration.getName() + "' failed, jobtype '" + jobConfiguration.getJobType() + "' is already running." ); "Job '" + jobConfiguration.getName() + "' failed, jobtype '" + jobConfiguration.getJobType() + "' is already running.", new Exception( "Job '" + jobConfiguration.getName() + "' failed" ) ); jobConfiguration.setLastExecutedStatus( JobStatus.FAILED ); messageService.sendSystemErrorNotification( "Job '" + jobConfiguration.getName() + "' failed", ex ); log.error( "Job '" + jobConfiguration.getName() + "' failed", ex ); jobConfiguration.setLastExecutedStatus( JobStatus.FAILED );
/** * Set status properties of job after finish. If the job was executed manually and the job is disabled we want * to set the status back to DISABLED. * * @param clock Clock for keeping track of time usage * @param schedulingManager reference to scheduling manager * @param jobConfiguration the job configuration */ private void setFinishingStatus( Clock clock, SchedulingManager schedulingManager, JobConfiguration jobConfiguration ) { if ( jobConfiguration.isInMemoryJob() ) { return; } if ( !jobConfiguration.isContinuousExecution() ) { jobConfiguration.setJobStatus( JobStatus.SCHEDULED ); } if ( !jobConfiguration.isEnabled() ) { jobConfiguration.setJobStatus( JobStatus.DISABLED ); } jobConfiguration.setNextExecutionTime( null ); jobConfiguration.setLastExecuted( new Date() ); jobConfiguration.setLastRuntimeExecution( clock.time() ); schedulingManager.jobConfigurationFinished( jobConfiguration ); }
public void clear( JobConfiguration jobConfiguration ) { notificationsWithType.get( jobConfiguration.getJobType() ).remove( jobConfiguration.getUid() ); summariesWithType.get( jobConfiguration.getJobType() ).remove( jobConfiguration.getUid() ); } }
.filter( configuration -> !Objects.equals( configuration.getUid(), jobConfiguration.getUid() ) ) .forEach( configuration -> { List<JobConfiguration> jobConfigurationList = new ArrayList<>(); List<JobConfiguration> oldList = jobConfigurationForJobTypes.get( configuration.getJobType() ); if ( oldList != null ) jobConfigurationForJobTypes.put( configuration.getJobType(), jobConfigurationList ); } ); List<JobConfiguration> listForJobType = jobConfigurationForJobTypes.get( jobConfiguration.getJobType() ); if ( jobConfiguration.isContinuousExecution() ) if ( jobConfig.isContinuousExecution() ) if ( jobConfig.getCronExpression().equals( jobConfiguration.getCronExpression() ) )
@Override public void electLeader() { log.debug( "Election attempt by nodeId:" + this.nodeId ); redisTemplate.getConnectionFactory().getConnection().set( key.getBytes(), nodeId.getBytes(), Expiration.from( timeToLiveSeconds, TimeUnit.SECONDS ), SetOption.SET_IF_ABSENT ); if ( isLeader() ) { renewLeader(); Calendar calendar = Calendar.getInstance(); calendar.add( Calendar.SECOND, (int) (this.timeToLiveSeconds / 2) ); log.debug( "Next leader renewal job nodeId:" + this.nodeId + " set at " + calendar.getTime().toString() ); JobConfiguration leaderRenewalJobConfiguration = new JobConfiguration( CLUSTER_LEADER_RENEWAL, JobType.LEADER_RENEWAL, null, null, false, true, true ); leaderRenewalJobConfiguration.setLeaderOnlyJob( true ); schedulingManager.scheduleJobWithStartTime( leaderRenewalJobConfiguration, calendar.getTime() ); } }
public void jobConfigurationFinished( JobConfiguration jobConfiguration ) { runningJobConfigurations.remove( jobConfiguration ); JobConfiguration tempJobConfiguration = jobConfigurationService .getJobConfigurationByUid( jobConfiguration.getUid() ); if ( tempJobConfiguration != null ) { if ( tempJobConfiguration.getJobStatus() == DISABLED ) { jobConfiguration.setJobStatus( DISABLED ); jobConfiguration.setEnabled( false ); } jobConfigurationService.updateJobConfiguration( jobConfiguration ); } }
@Override public void execute( JobConfiguration jobConfiguration ) throws Exception { PredictorJobParameters predictorJobParameters = ( PredictorJobParameters ) jobConfiguration.getJobParameters(); if ( predictorJobParameters == null ) { throw new Exception( "No job parameters present in predictor job" ); } predictionService.predictJob( predictorJobParameters, null ); } }
@Override public <T extends IdentifiableObject> List<ErrorReport> validate( T object, ObjectBundle bundle ) { if ( !JobConfiguration.class.isInstance( object ) ) { return new ArrayList<>(); } JobConfiguration jobConfiguration = (JobConfiguration) object; List<ErrorReport> errorReports = new ArrayList<>( validateInternal( jobConfiguration ) ); if ( errorReports.size() == 0 ) { jobConfiguration.setNextExecutionTime( null ); if ( jobConfiguration.isContinuousExecution() ) { jobConfiguration.setCronExpression( CONTINOUS_CRON ); } log.info( "Validation of '" + jobConfiguration.getName() + "' succeeded" ); } else { log.info( "Validation of '" + jobConfiguration.getName() + "' failed." ); log.info( errorReports ); } return errorReports; }
/** * Method which calls the execute method in the job. The job will run in this thread and finish, either with success * or with an exception. * * @param jobConfiguration the configuration to execute * @param schedulingManager a reference to the scheduling manager * @param clock refers to start time * @throws Exception if the job fails */ private void executeJob( JobConfiguration jobConfiguration, SchedulingManager schedulingManager, Clock clock ) throws Exception { log.debug( "Job '" + jobConfiguration.getName() + "' started" ); schedulingManager.getJob( jobConfiguration.getJobType() ).execute( jobConfiguration ); log.debug( "Job '" + jobConfiguration.getName() + "' executed successfully. Time used: " + clock.time() ); } }
jobId = new JobConfiguration( "inMemoryGenerateHtmlReport", JobType.PUSH_ANALYSIS, currentUserService.getCurrentUser().getUid(), true ); notifier.clear( jobId );
@Override public void scheduleJob( JobConfiguration jobConfiguration ) { if ( ifJobInSystemStop( jobConfiguration.getUid() ) ) { JobInstance jobInstance = new DefaultJobInstance(); if ( jobConfiguration.getUid() != null && !futures.containsKey( jobConfiguration.getUid() ) ) { ScheduledFuture<?> future = jobScheduler .schedule( () -> { try { jobInstance.execute( jobConfiguration, this, messageService, leaderManager ); } catch ( Exception e ) { log.error( DebugUtils.getStackTrace( e ) ); } }, new CronTrigger( jobConfiguration.getCronExpression() ) ); futures.put( jobConfiguration.getUid(), future ); log.info( "Scheduled job: " + jobConfiguration ); } } }
JobConfiguration dxfJobId = ( id == null ) ? null : new JobConfiguration( "dxfJob", JobType.DATAVALUE_IMPORT_INTERNAL, id.getUserUid(), true );
@Override public void stopJob( JobConfiguration jobConfiguration ) { if ( isJobInSystem( jobConfiguration.getUid() ) ) { jobConfiguration.setLastExecutedStatus( JobStatus.STOPPED ); jobConfigurationService.updateJobConfiguration( jobConfiguration ); internalStopJob( jobConfiguration.getUid() ); } }